diff --git a/.obsidian/app.json b/.obsidian/app.json index 4847cec..83fdb69 100644 --- a/.obsidian/app.json +++ b/.obsidian/app.json @@ -2,11 +2,13 @@ "vimMode": true, "promptDelete": false, "pdfExportSettings": { + "includeName": true, "pageSize": "Letter", "landscape": false, "margin": "0", "downscalePercent": 100 }, "spellcheck": true, - "focusNewTab": false + "focusNewTab": false, + "alwaysUpdateLinks": true } \ No newline at end of file diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index d3f66fa..75f91d9 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -1,3 +1,7 @@ [ - "obsidian-git" + "obsidian-git", + "d2-obsidian", + "execute-code", + "better-export-pdf", + "obsidian-excalidraw-plugin" ] \ No newline at end of file diff --git a/.obsidian/file-recovery.json b/.obsidian/file-recovery.json new file mode 100644 index 0000000..7197548 --- /dev/null +++ b/.obsidian/file-recovery.json @@ -0,0 +1,4 @@ +{ + "intervalMinutes": 5, + "keepDays": 7 +} \ No newline at end of file diff --git a/.obsidian/plugins/better-export-pdf/data.json b/.obsidian/plugins/better-export-pdf/data.json new file mode 100644 index 0000000..e9527ec --- /dev/null +++ b/.obsidian/plugins/better-export-pdf/data.json @@ -0,0 +1,29 @@ +{ + "showTitle": true, + "maxLevel": "6", + "displayHeader": true, + "displayFooter": true, + "headerTemplate": "
", + "footerTemplate": "
/
", + "printBackground": false, + "generateTaggedPDF": false, + "displayMetadata": false, + "debug": false, + "isTimestamp": false, + "enabledCss": false, + "prevConfig": { + "pageSize": "A4", + "marginType": "1", + "showTitle": true, + "open": true, + "scale": 100, + "landscape": false, + "marginTop": "10", + "marginBottom": "10", + "marginLeft": "10", + "marginRight": "10", + "displayHeader": true, + "displayFooter": true, + "cssSnippet": "0" + } +} \ No newline at end of file diff --git a/.obsidian/plugins/better-export-pdf/main.js b/.obsidian/plugins/better-export-pdf/main.js new file mode 100644 index 0000000..9271f1a --- /dev/null +++ b/.obsidian/plugins/better-export-pdf/main.js @@ -0,0 +1,21223 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js +var require_cjs = __commonJS({ + "node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"(exports, module2) { + "use strict"; + var isMergeableObject = function isMergeableObject2(value) { + return isNonNullObject(value) && !isSpecial(value); + }; + function isNonNullObject(value) { + return !!value && typeof value === "object"; + } + function isSpecial(value) { + var stringValue = Object.prototype.toString.call(value); + return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value); + } + var canUseSymbol = typeof Symbol === "function" && Symbol.for; + var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103; + function isReactElement(value) { + return value.$$typeof === REACT_ELEMENT_TYPE; + } + function emptyTarget(val) { + return Array.isArray(val) ? [] : {}; + } + function cloneUnlessOtherwiseSpecified(value, options) { + return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value; + } + function defaultArrayMerge(target, source, options) { + return target.concat(source).map(function(element) { + return cloneUnlessOtherwiseSpecified(element, options); + }); + } + function getMergeFunction(key, options) { + if (!options.customMerge) { + return deepmerge; + } + var customMerge = options.customMerge(key); + return typeof customMerge === "function" ? customMerge : deepmerge; + } + function getEnumerableOwnPropertySymbols(target) { + return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) { + return Object.propertyIsEnumerable.call(target, symbol); + }) : []; + } + function getKeys(target) { + return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target)); + } + function propertyIsOnObject(object, property) { + try { + return property in object; + } catch (_) { + return false; + } + } + function propertyIsUnsafe(target, key) { + return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key)); + } + function mergeObject(target, source, options) { + var destination = {}; + if (options.isMergeableObject(target)) { + getKeys(target).forEach(function(key) { + destination[key] = cloneUnlessOtherwiseSpecified(target[key], options); + }); + } + getKeys(source).forEach(function(key) { + if (propertyIsUnsafe(target, key)) { + return; + } + if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) { + destination[key] = getMergeFunction(key, options)(target[key], source[key], options); + } else { + destination[key] = cloneUnlessOtherwiseSpecified(source[key], options); + } + }); + return destination; + } + function deepmerge(target, source, options) { + options = options || {}; + options.arrayMerge = options.arrayMerge || defaultArrayMerge; + options.isMergeableObject = options.isMergeableObject || isMergeableObject; + options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified; + var sourceIsArray = Array.isArray(source); + var targetIsArray = Array.isArray(target); + var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray; + if (!sourceAndTargetTypesMatch) { + return cloneUnlessOtherwiseSpecified(source, options); + } else if (sourceIsArray) { + return options.arrayMerge(target, source, options); + } else { + return mergeObject(target, source, options); + } + } + deepmerge.all = function deepmergeAll(array, options) { + if (!Array.isArray(array)) { + throw new Error("first argument should be an array"); + } + return array.reduce(function(prev, next) { + return deepmerge(prev, next, options); + }, {}); + }; + var deepmerge_1 = deepmerge; + module2.exports = deepmerge_1; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/common.js +var require_common = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/common.js"(exports) { + "use strict"; + var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined"; + function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); + } + exports.assign = function(obj) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { + continue; + } + if (typeof source !== "object") { + throw new TypeError(source + "must be non-object"); + } + for (var p in source) { + if (_has(source, p)) { + obj[p] = source[p]; + } + } + } + return obj; + }; + exports.shrinkBuf = function(buf, size) { + if (buf.length === size) { + return buf; + } + if (buf.subarray) { + return buf.subarray(0, size); + } + buf.length = size; + return buf; + }; + var fnTyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function(chunks) { + var i, l, len, pos, chunk, result; + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + return result; + } + }; + var fnUntyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function(chunks) { + return [].concat.apply([], chunks); + } + }; + exports.setTyped = function(on) { + if (on) { + exports.Buf8 = Uint8Array; + exports.Buf16 = Uint16Array; + exports.Buf32 = Int32Array; + exports.assign(exports, fnTyped); + } else { + exports.Buf8 = Array; + exports.Buf16 = Array; + exports.Buf32 = Array; + exports.assign(exports, fnUntyped); + } + }; + exports.setTyped(TYPED_OK); + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/trees.js +var require_trees = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/trees.js"(exports) { + "use strict"; + var utils = require_common(); + var Z_FIXED = 4; + var Z_BINARY = 0; + var Z_TEXT = 1; + var Z_UNKNOWN = 2; + function zero(buf) { + var len = buf.length; + while (--len >= 0) { + buf[len] = 0; + } + } + var STORED_BLOCK = 0; + var STATIC_TREES = 1; + var DYN_TREES = 2; + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = LITERALS + 1 + LENGTH_CODES; + var D_CODES = 30; + var BL_CODES = 19; + var HEAP_SIZE = 2 * L_CODES + 1; + var MAX_BITS = 15; + var Buf_size = 16; + var MAX_BL_BITS = 7; + var END_BLOCK = 256; + var REP_3_6 = 16; + var REPZ_3_10 = 17; + var REPZ_11_138 = 18; + var extra_lbits = ( + /* extra bits for each length code */ + [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0] + ); + var extra_dbits = ( + /* extra bits for each distance code */ + [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13] + ); + var extra_blbits = ( + /* extra bits for each bit length code */ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7] + ); + var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + var DIST_CODE_LEN = 512; + var static_ltree = new Array((L_CODES + 2) * 2); + zero(static_ltree); + var static_dtree = new Array(D_CODES * 2); + zero(static_dtree); + var _dist_code = new Array(DIST_CODE_LEN); + zero(_dist_code); + var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1); + zero(_length_code); + var base_length = new Array(LENGTH_CODES); + zero(base_length); + var base_dist = new Array(D_CODES); + zero(base_dist); + function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + this.static_tree = static_tree; + this.extra_bits = extra_bits; + this.extra_base = extra_base; + this.elems = elems; + this.max_length = max_length; + this.has_stree = static_tree && static_tree.length; + } + var static_l_desc; + var static_d_desc; + var static_bl_desc; + function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; + this.max_code = 0; + this.stat_desc = stat_desc; + } + function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; + } + function put_short(s, w) { + s.pending_buf[s.pending++] = w & 255; + s.pending_buf[s.pending++] = w >>> 8 & 255; + } + function send_bits(s, value, length) { + if (s.bi_valid > Buf_size - length) { + s.bi_buf |= value << s.bi_valid & 65535; + put_short(s, s.bi_buf); + s.bi_buf = value >> Buf_size - s.bi_valid; + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= value << s.bi_valid & 65535; + s.bi_valid += length; + } + } + function send_code(s, c, tree) { + send_bits( + s, + tree[c * 2], + tree[c * 2 + 1] + /*.Len*/ + ); + } + function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; + } + function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 255; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } + } + function gen_bitlen(s, desc) { + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; + var n, m; + var bits; + var xbits; + var f; + var overflow = 0; + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + tree[s.heap[s.heap_max] * 2 + 1] = 0; + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1] * 2 + 1] + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1] = bits; + if (n > max_code) { + continue; + } + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n - base]; + } + f = tree[n * 2]; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n * 2 + 1] + xbits); + } + } + if (overflow === 0) { + return; + } + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { + bits--; + } + s.bl_count[bits]--; + s.bl_count[bits + 1] += 2; + s.bl_count[max_length]--; + overflow -= 2; + } while (overflow > 0); + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { + continue; + } + if (tree[m * 2 + 1] !== bits) { + s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2]; + tree[m * 2 + 1] = bits; + } + n--; + } + } + } + function gen_codes(tree, max_code, bl_count) { + var next_code = new Array(MAX_BITS + 1); + var code = 0; + var bits; + var n; + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = code + bl_count[bits - 1] << 1; + } + for (n = 0; n <= max_code; n++) { + var len = tree[n * 2 + 1]; + if (len === 0) { + continue; + } + tree[n * 2] = bi_reverse(next_code[len]++, len); + } + } + function tr_static_init() { + var n; + var bits; + var length; + var code; + var dist; + var bl_count = new Array(MAX_BITS + 1); + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < 1 << extra_lbits[code]; n++) { + _length_code[length++] = code; + } + } + _length_code[length - 1] = code; + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < 1 << extra_dbits[code]; n++) { + _dist_code[dist++] = code; + } + } + dist >>= 7; + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < 1 << extra_dbits[code] - 7; n++) { + _dist_code[256 + dist++] = code; + } + } + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + n = 0; + while (n <= 143) { + static_ltree[n * 2 + 1] = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n * 2 + 1] = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n * 2 + 1] = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n * 2 + 1] = 8; + n++; + bl_count[8]++; + } + gen_codes(static_ltree, L_CODES + 1, bl_count); + for (n = 0; n < D_CODES; n++) { + static_dtree[n * 2 + 1] = 5; + static_dtree[n * 2] = bi_reverse(n, 5); + } + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + } + function init_block(s) { + var n; + for (n = 0; n < L_CODES; n++) { + s.dyn_ltree[n * 2] = 0; + } + for (n = 0; n < D_CODES; n++) { + s.dyn_dtree[n * 2] = 0; + } + for (n = 0; n < BL_CODES; n++) { + s.bl_tree[n * 2] = 0; + } + s.dyn_ltree[END_BLOCK * 2] = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; + } + function bi_windup(s) { + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; + } + function copy_block(s, buf, len, header) { + bi_windup(s); + if (header) { + put_short(s, len); + put_short(s, ~len); + } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; + } + function smaller(tree, n, m, depth) { + var _n2 = n * 2; + var _m2 = m * 2; + return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m]; + } + function pqdownheap(s, tree, k) { + var v = s.heap[k]; + var j = k << 1; + while (j <= s.heap_len) { + if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + if (smaller(tree, v, s.heap[j], s.depth)) { + break; + } + s.heap[k] = s.heap[j]; + k = j; + j <<= 1; + } + s.heap[k] = v; + } + function compress_block(s, ltree, dtree) { + var dist; + var lc; + var lx = 0; + var code; + var extra; + if (s.last_lit !== 0) { + do { + dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1]; + lc = s.pending_buf[s.l_buf + lx]; + lx++; + if (dist === 0) { + send_code(s, lc, ltree); + } else { + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); + } + dist--; + code = d_code(dist); + send_code(s, code, dtree); + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); + } + } + } while (lx < s.last_lit); + } + send_code(s, END_BLOCK, ltree); + } + function build_tree(s, desc) { + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; + var max_code = -1; + var node; + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + for (n = 0; n < elems; n++) { + if (tree[n * 2] !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + } else { + tree[n * 2 + 1] = 0; + } + } + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0; + tree[node * 2] = 1; + s.depth[node] = 0; + s.opt_len--; + if (has_stree) { + s.static_len -= stree[node * 2 + 1]; + } + } + desc.max_code = max_code; + for (n = s.heap_len >> 1; n >= 1; n--) { + pqdownheap(s, tree, n); + } + node = elems; + do { + n = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[ + 1 + /*SMALLEST*/ + ] = s.heap[s.heap_len--]; + pqdownheap( + s, + tree, + 1 + /*SMALLEST*/ + ); + m = s.heap[ + 1 + /*SMALLEST*/ + ]; + s.heap[--s.heap_max] = n; + s.heap[--s.heap_max] = m; + tree[node * 2] = tree[n * 2] + tree[m * 2]; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n * 2 + 1] = tree[m * 2 + 1] = node; + s.heap[ + 1 + /*SMALLEST*/ + ] = node++; + pqdownheap( + s, + tree, + 1 + /*SMALLEST*/ + ); + } while (s.heap_len >= 2); + s.heap[--s.heap_max] = s.heap[ + 1 + /*SMALLEST*/ + ]; + gen_bitlen(s, desc); + gen_codes(tree, max_code, s.bl_count); + } + function scan_tree(s, tree, max_code) { + var n; + var prevlen = -1; + var curlen; + var nextlen = tree[0 * 2 + 1]; + var count = 0; + var max_count = 7; + var min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1] = 65535; + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen === nextlen) { + continue; + } else if (count < min_count) { + s.bl_tree[curlen * 2] += count; + } else if (curlen !== 0) { + if (curlen !== prevlen) { + s.bl_tree[curlen * 2]++; + } + s.bl_tree[REP_3_6 * 2]++; + } else if (count <= 10) { + s.bl_tree[REPZ_3_10 * 2]++; + } else { + s.bl_tree[REPZ_11_138 * 2]++; + } + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + } + function send_tree(s, tree, max_code) { + var n; + var prevlen = -1; + var curlen; + var nextlen = tree[0 * 2 + 1]; + var count = 0; + var max_count = 7; + var min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen === nextlen) { + continue; + } else if (count < min_count) { + do { + send_code(s, curlen, s.bl_tree); + } while (--count !== 0); + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count - 3, 2); + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count - 3, 3); + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count - 11, 7); + } + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + } + function build_bl_tree(s) { + var max_blindex; + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + build_tree(s, s.bl_desc); + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) { + break; + } + } + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + return max_blindex; + } + function send_all_trees(s, lcodes, dcodes, blcodes) { + var rank; + send_bits(s, lcodes - 257, 5); + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); + for (rank = 0; rank < blcodes; rank++) { + send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3); + } + send_tree(s, s.dyn_ltree, lcodes - 1); + send_tree(s, s.dyn_dtree, dcodes - 1); + } + function detect_data_type(s) { + var black_mask = 4093624447; + var n; + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) { + return Z_BINARY; + } + } + if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2] !== 0) { + return Z_TEXT; + } + } + return Z_BINARY; + } + var static_init_done = false; + function _tr_init(s) { + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + s.bi_buf = 0; + s.bi_valid = 0; + init_block(s); + } + function _tr_stored_block(s, buf, stored_len, last2) { + send_bits(s, (STORED_BLOCK << 1) + (last2 ? 1 : 0), 3); + copy_block(s, buf, stored_len, true); + } + function _tr_align(s) { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); + } + function _tr_flush_block(s, buf, stored_len, last2) { + var opt_lenb, static_lenb; + var max_blindex = 0; + if (s.level > 0) { + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + build_tree(s, s.l_desc); + build_tree(s, s.d_desc); + max_blindex = build_bl_tree(s); + opt_lenb = s.opt_len + 3 + 7 >>> 3; + static_lenb = s.static_len + 3 + 7 >>> 3; + if (static_lenb <= opt_lenb) { + opt_lenb = static_lenb; + } + } else { + opt_lenb = static_lenb = stored_len + 5; + } + if (stored_len + 4 <= opt_lenb && buf !== -1) { + _tr_stored_block(s, buf, stored_len, last2); + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + send_bits(s, (STATIC_TREES << 1) + (last2 ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + } else { + send_bits(s, (DYN_TREES << 1) + (last2 ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + init_block(s); + if (last2) { + bi_windup(s); + } + } + function _tr_tally(s, dist, lc) { + s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 255; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255; + s.pending_buf[s.l_buf + s.last_lit] = lc & 255; + s.last_lit++; + if (dist === 0) { + s.dyn_ltree[lc * 2]++; + } else { + s.matches++; + dist--; + s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++; + s.dyn_dtree[d_code(dist) * 2]++; + } + return s.last_lit === s.lit_bufsize - 1; + } + exports._tr_init = _tr_init; + exports._tr_stored_block = _tr_stored_block; + exports._tr_flush_block = _tr_flush_block; + exports._tr_tally = _tr_tally; + exports._tr_align = _tr_align; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/adler32.js +var require_adler32 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/adler32.js"(exports, module2) { + "use strict"; + function adler32(adler, buf, len, pos) { + var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0; + while (len !== 0) { + n = len > 2e3 ? 2e3 : len; + len -= n; + do { + s1 = s1 + buf[pos++] | 0; + s2 = s2 + s1 | 0; + } while (--n); + s1 %= 65521; + s2 %= 65521; + } + return s1 | s2 << 16 | 0; + } + module2.exports = adler32; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/crc32.js +var require_crc32 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/crc32.js"(exports, module2) { + "use strict"; + function makeTable() { + var c, table = []; + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1; + } + table[n] = c; + } + return table; + } + var crcTable = makeTable(); + function crc32(crc, buf, len, pos) { + var t = crcTable, end = pos + len; + crc ^= -1; + for (var i = pos; i < end; i++) { + crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255]; + } + return crc ^ -1; + } + module2.exports = crc32; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/messages.js +var require_messages = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/messages.js"(exports, module2) { + "use strict"; + module2.exports = { + 2: "need dictionary", + /* Z_NEED_DICT 2 */ + 1: "stream end", + /* Z_STREAM_END 1 */ + 0: "", + /* Z_OK 0 */ + "-1": "file error", + /* Z_ERRNO (-1) */ + "-2": "stream error", + /* Z_STREAM_ERROR (-2) */ + "-3": "data error", + /* Z_DATA_ERROR (-3) */ + "-4": "insufficient memory", + /* Z_MEM_ERROR (-4) */ + "-5": "buffer error", + /* Z_BUF_ERROR (-5) */ + "-6": "incompatible version" + /* Z_VERSION_ERROR (-6) */ + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/deflate.js +var require_deflate = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/deflate.js"(exports) { + "use strict"; + var utils = require_common(); + var trees = require_trees(); + var adler32 = require_adler32(); + var crc32 = require_crc32(); + var msg = require_messages(); + var Z_NO_FLUSH = 0; + var Z_PARTIAL_FLUSH = 1; + var Z_FULL_FLUSH = 3; + var Z_FINISH = 4; + var Z_BLOCK = 5; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_BUF_ERROR = -5; + var Z_DEFAULT_COMPRESSION = -1; + var Z_FILTERED = 1; + var Z_HUFFMAN_ONLY = 2; + var Z_RLE = 3; + var Z_FIXED = 4; + var Z_DEFAULT_STRATEGY = 0; + var Z_UNKNOWN = 2; + var Z_DEFLATED = 8; + var MAX_MEM_LEVEL = 9; + var MAX_WBITS = 15; + var DEF_MEM_LEVEL = 8; + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = LITERALS + 1 + LENGTH_CODES; + var D_CODES = 30; + var BL_CODES = 19; + var HEAP_SIZE = 2 * L_CODES + 1; + var MAX_BITS = 15; + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; + var PRESET_DICT = 32; + var INIT_STATE = 42; + var EXTRA_STATE = 69; + var NAME_STATE = 73; + var COMMENT_STATE = 91; + var HCRC_STATE = 103; + var BUSY_STATE = 113; + var FINISH_STATE = 666; + var BS_NEED_MORE = 1; + var BS_BLOCK_DONE = 2; + var BS_FINISH_STARTED = 3; + var BS_FINISH_DONE = 4; + var OS_CODE = 3; + function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; + } + function rank(f) { + return (f << 1) - (f > 4 ? 9 : 0); + } + function zero(buf) { + var len = buf.length; + while (--len >= 0) { + buf[len] = 0; + } + } + function flush_pending(strm) { + var s = strm.state; + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { + return; + } + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } + } + function flush_block_only(s, last2) { + trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last2); + s.block_start = s.strstart; + flush_pending(s.strm); + } + function put_byte(s, b) { + s.pending_buf[s.pending++] = b; + } + function putShortMSB(s, b) { + s.pending_buf[s.pending++] = b >>> 8 & 255; + s.pending_buf[s.pending++] = b & 255; + } + function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + if (len > size) { + len = size; + } + if (len === 0) { + return 0; + } + strm.avail_in -= len; + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } else if (strm.state.wrap === 2) { + strm.adler = crc32(strm.adler, buf, len, start); + } + strm.next_in += len; + strm.total_in += len; + return len; + } + function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; + var scan = s.strstart; + var match; + var len; + var best_len = s.prev_length; + var nice_match = s.nice_match; + var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0; + var _win = s.window; + var wmask = s.w_mask; + var prev = s.prev; + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + if (nice_match > s.lookahead) { + nice_match = s.lookahead; + } + do { + match = cur_match; + if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) { + continue; + } + scan += 2; + match++; + do { + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend); + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; + } + function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + do { + more = s.window_size - s.lookahead - s.strstart; + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + s.block_start -= _w_size; + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = m >= _w_size ? m - _w_size : 0; + } while (--n); + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = m >= _w_size ? m - _w_size : 0; + } while (--n); + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask; + while (s.insert) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + } + function deflate_stored(s, flush) { + var max_block_size = 65535; + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + for (; ; ) { + if (s.lookahead <= 1) { + fill_window(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.strstart += s.lookahead; + s.lookahead = 0; + var max_start = s.block_start + max_block_size; + if (s.strstart === 0 || s.strstart >= max_start) { + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.strstart > s.block_start) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_NEED_MORE; + } + function deflate_fast(s, flush) { + var hash_head; + var bflush; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + } + if (s.match_length >= MIN_MATCH) { + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) { + s.match_length--; + do { + s.strstart++; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } while (--s.match_length !== 0); + s.strstart++; + } else { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask; + } + } else { + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_slow(s, flush) { + var hash_head; + var bflush; + var max_insert; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) { + s.match_length = MIN_MATCH - 1; + } + } + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } else if (s.match_available) { + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + if (bflush) { + flush_block_only(s, false); + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + if (s.match_available) { + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_rle(s, flush) { + var bflush; + var prev; + var scan, strend; + var _win = s.window; + for (; ; ) { + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + } + if (s.match_length >= MIN_MATCH) { + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_huff(s, flush) { + var bflush; + for (; ; ) { + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; + } + } + s.match_length = 0; + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; + } + var configuration_table; + configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), + /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), + /* 1 max speed, no lazy matches */ + new Config(4, 5, 16, 8, deflate_fast), + /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), + /* 3 */ + new Config(4, 4, 16, 16, deflate_slow), + /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), + /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), + /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), + /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), + /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) + /* 9 max compression */ + ]; + function lm_init(s) { + s.window_size = 2 * s.w_size; + zero(s.head); + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; + } + function DeflateState() { + this.strm = null; + this.status = 0; + this.pending_buf = null; + this.pending_buf_size = 0; + this.pending_out = 0; + this.pending = 0; + this.wrap = 0; + this.gzhead = null; + this.gzindex = 0; + this.method = Z_DEFLATED; + this.last_flush = -1; + this.w_size = 0; + this.w_bits = 0; + this.w_mask = 0; + this.window = null; + this.window_size = 0; + this.prev = null; + this.head = null; + this.ins_h = 0; + this.hash_size = 0; + this.hash_bits = 0; + this.hash_mask = 0; + this.hash_shift = 0; + this.block_start = 0; + this.match_length = 0; + this.prev_match = 0; + this.match_available = 0; + this.strstart = 0; + this.match_start = 0; + this.lookahead = 0; + this.prev_length = 0; + this.max_chain_length = 0; + this.max_lazy_match = 0; + this.level = 0; + this.strategy = 0; + this.good_match = 0; + this.nice_match = 0; + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2); + this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + this.l_desc = null; + this.d_desc = null; + this.bl_desc = null; + this.bl_count = new utils.Buf16(MAX_BITS + 1); + this.heap = new utils.Buf16(2 * L_CODES + 1); + zero(this.heap); + this.heap_len = 0; + this.heap_max = 0; + this.depth = new utils.Buf16(2 * L_CODES + 1); + zero(this.depth); + this.l_buf = 0; + this.lit_bufsize = 0; + this.last_lit = 0; + this.d_buf = 0; + this.opt_len = 0; + this.static_len = 0; + this.matches = 0; + this.insert = 0; + this.bi_buf = 0; + this.bi_valid = 0; + } + function deflateResetKeep(strm) { + var s; + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + s = strm.state; + s.pending = 0; + s.pending_out = 0; + if (s.wrap < 0) { + s.wrap = -s.wrap; + } + s.status = s.wrap ? INIT_STATE : BUSY_STATE; + strm.adler = s.wrap === 2 ? 0 : 1; + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; + } + function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; + } + function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + if (strm.state.wrap !== 2) { + return Z_STREAM_ERROR; + } + strm.state.gzhead = head; + return Z_OK; + } + function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { + if (!strm) { + return Z_STREAM_ERROR; + } + var wrap = 1; + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else if (windowBits > 15) { + wrap = 2; + windowBits -= 16; + } + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + if (windowBits === 8) { + windowBits = 9; + } + var s = new DeflateState(); + strm.state = s; + s.strm = strm; + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + s.lit_bufsize = 1 << memLevel + 6; + s.pending_buf_size = s.lit_bufsize * 4; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + s.d_buf = 1 * s.lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + s.level = level; + s.strategy = strategy; + s.method = method; + return deflateReset(strm); + } + function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); + } + function deflate(strm, flush) { + var old_flush, s; + var beg, val; + if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + s = strm.state; + if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z_FINISH) { + return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + s.strm = strm; + old_flush = s.last_flush; + s.last_flush = flush; + if (s.status === INIT_STATE) { + if (s.wrap === 2) { + strm.adler = 0; + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } else { + put_byte( + s, + (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 255); + put_byte(s, s.gzhead.time >> 8 & 255); + put_byte(s, s.gzhead.time >> 16 & 255); + put_byte(s, s.gzhead.time >> 24 & 255); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, s.gzhead.os & 255); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 255); + put_byte(s, s.gzhead.extra.length >> 8 & 255); + } + if (s.gzhead.hcrc) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } else { + var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8; + var level_flags = -1; + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= level_flags << 6; + if (s.strstart !== 0) { + header |= PRESET_DICT; + } + header += 31 - header % 31; + s.status = BUSY_STATE; + putShortMSB(s, header); + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + strm.adler = 1; + } + } + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra) { + beg = s.pending; + while (s.gzindex < (s.gzhead.extra.length & 65535)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 255); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + strm.adler = 0; + s.status = BUSY_STATE; + } + } else { + s.status = BUSY_STATE; + } + } + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK; + } + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) { + var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush); + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + } + return Z_OK; + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } else if (flush !== Z_BLOCK) { + trees._tr_stored_block(s, 0, 0, false); + if (flush === Z_FULL_FLUSH) { + zero(s.head); + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK; + } + } + } + if (flush !== Z_FINISH) { + return Z_OK; + } + if (s.wrap <= 0) { + return Z_STREAM_END; + } + if (s.wrap === 2) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + put_byte(s, strm.adler >> 16 & 255); + put_byte(s, strm.adler >> 24 & 255); + put_byte(s, strm.total_in & 255); + put_byte(s, strm.total_in >> 8 & 255); + put_byte(s, strm.total_in >> 16 & 255); + put_byte(s, strm.total_in >> 24 & 255); + } else { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + flush_pending(strm); + if (s.wrap > 0) { + s.wrap = -s.wrap; + } + return s.pending !== 0 ? Z_OK : Z_STREAM_END; + } + function deflateEnd(strm) { + var status; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + status = strm.state.status; + if (status !== INIT_STATE && status !== EXTRA_STATE && status !== NAME_STATE && status !== COMMENT_STATE && status !== HCRC_STATE && status !== BUSY_STATE && status !== FINISH_STATE) { + return err(strm, Z_STREAM_ERROR); + } + strm.state = null; + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; + } + function deflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + var s; + var str, n; + var wrap; + var avail; + var next; + var input; + var tmpDict; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + s = strm.state; + wrap = s.wrap; + if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) { + return Z_STREAM_ERROR; + } + if (wrap === 1) { + strm.adler = adler32(strm.adler, dictionary, dictLength, 0); + } + s.wrap = 0; + if (dictLength >= s.w_size) { + if (wrap === 0) { + zero(s.head); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + tmpDict = new utils.Buf8(s.w_size); + utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + avail = strm.avail_in; + next = strm.next_in; + input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + str = s.strstart; + n = s.lookahead - (MIN_MATCH - 1); + do { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + } while (--n); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK; + } + exports.deflateInit = deflateInit; + exports.deflateInit2 = deflateInit2; + exports.deflateReset = deflateReset; + exports.deflateResetKeep = deflateResetKeep; + exports.deflateSetHeader = deflateSetHeader; + exports.deflate = deflate; + exports.deflateEnd = deflateEnd; + exports.deflateSetDictionary = deflateSetDictionary; + exports.deflateInfo = "pako deflate (from Nodeca project)"; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/strings.js +var require_strings = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/utils/strings.js"(exports) { + "use strict"; + var utils = require_common(); + var STR_APPLY_OK = true; + var STR_APPLY_UIA_OK = true; + try { + String.fromCharCode.apply(null, [0]); + } catch (__) { + STR_APPLY_OK = false; + } + try { + String.fromCharCode.apply(null, new Uint8Array(1)); + } catch (__) { + STR_APPLY_UIA_OK = false; + } + var _utf8len = new utils.Buf8(256); + for (q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + var q; + _utf8len[254] = _utf8len[254] = 1; + exports.string2buf = function(str) { + var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; + for (m_pos = 0; m_pos < str_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4; + } + buf = new utils.Buf8(buf_len); + for (i = 0, m_pos = 0; i < buf_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + if (c < 128) { + buf[i++] = c; + } else if (c < 2048) { + buf[i++] = 192 | c >>> 6; + buf[i++] = 128 | c & 63; + } else if (c < 65536) { + buf[i++] = 224 | c >>> 12; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } else { + buf[i++] = 240 | c >>> 18; + buf[i++] = 128 | c >>> 12 & 63; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } + } + return buf; + }; + function buf2binstring(buf, len) { + if (len < 65534) { + if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) { + return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)); + } + } + var result = ""; + for (var i = 0; i < len; i++) { + result += String.fromCharCode(buf[i]); + } + return result; + } + exports.buf2binstring = function(buf) { + return buf2binstring(buf, buf.length); + }; + exports.binstring2buf = function(str) { + var buf = new utils.Buf8(str.length); + for (var i = 0, len = buf.length; i < len; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; + }; + exports.buf2string = function(buf, max) { + var i, out, c, c_len; + var len = max || buf.length; + var utf16buf = new Array(len * 2); + for (out = 0, i = 0; i < len; ) { + c = buf[i++]; + if (c < 128) { + utf16buf[out++] = c; + continue; + } + c_len = _utf8len[c]; + if (c_len > 4) { + utf16buf[out++] = 65533; + i += c_len - 1; + continue; + } + c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; + while (c_len > 1 && i < len) { + c = c << 6 | buf[i++] & 63; + c_len--; + } + if (c_len > 1) { + utf16buf[out++] = 65533; + continue; + } + if (c < 65536) { + utf16buf[out++] = c; + } else { + c -= 65536; + utf16buf[out++] = 55296 | c >> 10 & 1023; + utf16buf[out++] = 56320 | c & 1023; + } + } + return buf2binstring(utf16buf, out); + }; + exports.utf8border = function(buf, max) { + var pos; + max = max || buf.length; + if (max > buf.length) { + max = buf.length; + } + pos = max - 1; + while (pos >= 0 && (buf[pos] & 192) === 128) { + pos--; + } + if (pos < 0) { + return max; + } + if (pos === 0) { + return max; + } + return pos + _utf8len[buf[pos]] > max ? pos : max; + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/zstream.js +var require_zstream = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/zstream.js"(exports, module2) { + "use strict"; + function ZStream() { + this.input = null; + this.next_in = 0; + this.avail_in = 0; + this.total_in = 0; + this.output = null; + this.next_out = 0; + this.avail_out = 0; + this.total_out = 0; + this.msg = ""; + this.state = null; + this.data_type = 2; + this.adler = 0; + } + module2.exports = ZStream; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/deflate.js +var require_deflate2 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/deflate.js"(exports) { + "use strict"; + var zlib_deflate = require_deflate(); + var utils = require_common(); + var strings = require_strings(); + var msg = require_messages(); + var ZStream = require_zstream(); + var toString = Object.prototype.toString; + var Z_NO_FLUSH = 0; + var Z_FINISH = 4; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_SYNC_FLUSH = 2; + var Z_DEFAULT_COMPRESSION = -1; + var Z_DEFAULT_STRATEGY = 0; + var Z_DEFLATED = 8; + function Deflate(options) { + if (!(this instanceof Deflate)) return new Deflate(options); + this.options = utils.assign({ + level: Z_DEFAULT_COMPRESSION, + method: Z_DEFLATED, + chunkSize: 16384, + windowBits: 15, + memLevel: 8, + strategy: Z_DEFAULT_STRATEGY, + to: "" + }, options || {}); + var opt = this.options; + if (opt.raw && opt.windowBits > 0) { + opt.windowBits = -opt.windowBits; + } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) { + opt.windowBits += 16; + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new ZStream(); + this.strm.avail_out = 0; + var status = zlib_deflate.deflateInit2( + this.strm, + opt.level, + opt.method, + opt.windowBits, + opt.memLevel, + opt.strategy + ); + if (status !== Z_OK) { + throw new Error(msg[status]); + } + if (opt.header) { + zlib_deflate.deflateSetHeader(this.strm, opt.header); + } + if (opt.dictionary) { + var dict; + if (typeof opt.dictionary === "string") { + dict = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + dict = new Uint8Array(opt.dictionary); + } else { + dict = opt.dictionary; + } + status = zlib_deflate.deflateSetDictionary(this.strm, dict); + if (status !== Z_OK) { + throw new Error(msg[status]); + } + this._dict_set = true; + } + } + Deflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var status, _mode; + if (this.ended) { + return false; + } + _mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH; + if (typeof data === "string") { + strm.input = strings.string2buf(data); + } else if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = zlib_deflate.deflate(strm, _mode); + if (status !== Z_STREAM_END && status !== Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) { + if (this.options.to === "string") { + this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out))); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END); + if (_mode === Z_FINISH) { + status = zlib_deflate.deflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === Z_OK; + } + if (_mode === Z_SYNC_FLUSH) { + this.onEnd(Z_OK); + strm.avail_out = 0; + return true; + } + return true; + }; + Deflate.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Deflate.prototype.onEnd = function(status) { + if (status === Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function deflate(input, options) { + var deflator = new Deflate(options); + deflator.push(input, true); + if (deflator.err) { + throw deflator.msg || msg[deflator.err]; + } + return deflator.result; + } + function deflateRaw(input, options) { + options = options || {}; + options.raw = true; + return deflate(input, options); + } + function gzip(input, options) { + options = options || {}; + options.gzip = true; + return deflate(input, options); + } + exports.Deflate = Deflate; + exports.deflate = deflate; + exports.deflateRaw = deflateRaw; + exports.gzip = gzip; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inffast.js +var require_inffast = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inffast.js"(exports, module2) { + "use strict"; + var BAD = 30; + var TYPE = 12; + module2.exports = function inflate_fast(strm, start) { + var state; + var _in; + var last2; + var _out; + var beg; + var end; + var dmax; + var wsize; + var whave; + var wnext; + var s_window; + var hold; + var bits; + var lcode; + var dcode; + var lmask; + var dmask; + var here; + var op; + var len; + var dist; + var from; + var from_source; + var input, output; + state = strm.state; + _in = strm.next_in; + input = strm.input; + last2 = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); + dmax = state.dmax; + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op === 0) { + output[_out++] = here & 65535; + } else if (op & 16) { + len = here & 65535; + op &= 15; + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & (1 << op) - 1; + hold >>>= op; + bits -= op; + } + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op & 16) { + dist = here & 65535; + op &= 15; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & (1 << op) - 1; + if (dist > dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break top; + } + hold >>>= op; + bits -= op; + op = _out - beg; + if (dist > op) { + op = dist - op; + if (op > whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break top; + } + } + from = 0; + from_source = s_window; + if (wnext === 0) { + from += wsize - op; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } else if (wnext < op) { + from += wsize + wnext - op; + op -= wnext; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + } else { + from += wnext - op; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } else { + from = _out - dist; + do { + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } else if ((op & 64) === 0) { + here = dcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dodist; + } else { + strm.msg = "invalid distance code"; + state.mode = BAD; + break top; + } + break; + } + } else if ((op & 64) === 0) { + here = lcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dolen; + } else if (op & 32) { + state.mode = TYPE; + break top; + } else { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break top; + } + break; + } + } while (_in < last2 && _out < end); + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = _in < last2 ? 5 + (last2 - _in) : 5 - (_in - last2); + strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end); + state.hold = hold; + state.bits = bits; + return; + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inftrees.js +var require_inftrees = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inftrees.js"(exports, module2) { + "use strict"; + var utils = require_common(); + var MAXBITS = 15; + var ENOUGH_LENS = 852; + var ENOUGH_DISTS = 592; + var CODES = 0; + var LENS = 1; + var DISTS = 2; + var lbase = [ + /* Length codes 257..285 base */ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 13, + 15, + 17, + 19, + 23, + 27, + 31, + 35, + 43, + 51, + 59, + 67, + 83, + 99, + 115, + 131, + 163, + 195, + 227, + 258, + 0, + 0 + ]; + var lext = [ + /* Length codes 257..285 extra */ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 19, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 16, + 72, + 78 + ]; + var dbase = [ + /* Distance codes 0..29 base */ + 1, + 2, + 3, + 4, + 5, + 7, + 9, + 13, + 17, + 25, + 33, + 49, + 65, + 97, + 129, + 193, + 257, + 385, + 513, + 769, + 1025, + 1537, + 2049, + 3073, + 4097, + 6145, + 8193, + 12289, + 16385, + 24577, + 0, + 0 + ]; + var dext = [ + /* Distance codes 0..29 extra */ + 16, + 16, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 64, + 64 + ]; + module2.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) { + var bits = opts.bits; + var len = 0; + var sym = 0; + var min = 0, max = 0; + var root = 0; + var curr = 0; + var drop = 0; + var left = 0; + var used = 0; + var huff = 0; + var incr; + var fill2; + var low; + var mask; + var next; + var base = null; + var base_index = 0; + var end; + var count = new utils.Buf16(MAXBITS + 1); + var offs = new utils.Buf16(MAXBITS + 1); + var extra = null; + var extra_index = 0; + var here_bits, here_op, here_val; + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { + break; + } + } + if (root > max) { + root = max; + } + if (max === 0) { + table[table_index++] = 1 << 24 | 64 << 16 | 0; + table[table_index++] = 1 << 24 | 64 << 16 | 0; + opts.bits = 1; + return 0; + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { + break; + } + } + if (root < min) { + root = min; + } + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; + } + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + if (type === CODES) { + base = extra = work; + end = 19; + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + } else { + base = dbase; + extra = dext; + end = -1; + } + huff = 0; + sym = 0; + len = min; + next = table_index; + curr = root; + drop = 0; + low = -1; + used = 1 << root; + mask = used - 1; + if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) { + return 1; + } + for (; ; ) { + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } else { + here_op = 32 + 64; + here_val = 0; + } + incr = 1 << len - drop; + fill2 = 1 << curr; + min = fill2; + do { + fill2 -= incr; + table[next + (huff >> drop) + fill2] = here_bits << 24 | here_op << 16 | here_val | 0; + } while (fill2 !== 0); + incr = 1 << len - 1; + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + sym++; + if (--count[len] === 0) { + if (len === max) { + break; + } + len = lens[lens_index + work[sym]]; + } + if (len > root && (huff & mask) !== low) { + if (drop === 0) { + drop = root; + } + next += min; + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { + break; + } + curr++; + left <<= 1; + } + used += 1 << curr; + if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) { + return 1; + } + low = huff & mask; + table[low] = root << 24 | curr << 16 | next - table_index | 0; + } + } + if (huff !== 0) { + table[next + huff] = len - drop << 24 | 64 << 16 | 0; + } + opts.bits = root; + return 0; + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inflate.js +var require_inflate = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/inflate.js"(exports) { + "use strict"; + var utils = require_common(); + var adler32 = require_adler32(); + var crc32 = require_crc32(); + var inflate_fast = require_inffast(); + var inflate_table = require_inftrees(); + var CODES = 0; + var LENS = 1; + var DISTS = 2; + var Z_FINISH = 4; + var Z_BLOCK = 5; + var Z_TREES = 6; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_NEED_DICT = 2; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_MEM_ERROR = -4; + var Z_BUF_ERROR = -5; + var Z_DEFLATED = 8; + var HEAD = 1; + var FLAGS = 2; + var TIME = 3; + var OS = 4; + var EXLEN = 5; + var EXTRA = 6; + var NAME = 7; + var COMMENT = 8; + var HCRC = 9; + var DICTID = 10; + var DICT = 11; + var TYPE = 12; + var TYPEDO = 13; + var STORED = 14; + var COPY_ = 15; + var COPY = 16; + var TABLE = 17; + var LENLENS = 18; + var CODELENS = 19; + var LEN_ = 20; + var LEN = 21; + var LENEXT = 22; + var DIST = 23; + var DISTEXT = 24; + var MATCH = 25; + var LIT = 26; + var CHECK = 27; + var LENGTH = 28; + var DONE = 29; + var BAD = 30; + var MEM = 31; + var SYNC = 32; + var ENOUGH_LENS = 852; + var ENOUGH_DISTS = 592; + var MAX_WBITS = 15; + var DEF_WBITS = MAX_WBITS; + function zswap32(q) { + return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24); + } + function InflateState() { + this.mode = 0; + this.last = false; + this.wrap = 0; + this.havedict = false; + this.flags = 0; + this.dmax = 0; + this.check = 0; + this.total = 0; + this.head = null; + this.wbits = 0; + this.wsize = 0; + this.whave = 0; + this.wnext = 0; + this.window = null; + this.hold = 0; + this.bits = 0; + this.length = 0; + this.offset = 0; + this.extra = 0; + this.lencode = null; + this.distcode = null; + this.lenbits = 0; + this.distbits = 0; + this.ncode = 0; + this.nlen = 0; + this.ndist = 0; + this.have = 0; + this.next = null; + this.lens = new utils.Buf16(320); + this.work = new utils.Buf16(288); + this.lendyn = null; + this.distdyn = null; + this.sane = 0; + this.back = 0; + this.was = 0; + } + function inflateResetKeep(strm) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ""; + if (state.wrap) { + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null; + state.hold = 0; + state.bits = 0; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + state.sane = 1; + state.back = -1; + return Z_OK; + } + function inflateReset(strm) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + } + function inflateReset2(strm, windowBits) { + var wrap; + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); + } + function inflateInit2(strm, windowBits) { + var ret; + var state; + if (!strm) { + return Z_STREAM_ERROR; + } + state = new InflateState(); + strm.state = state; + state.window = null; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null; + } + return ret; + } + function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); + } + var virgin = true; + var lenfix; + var distfix; + function fixedtables(state) { + if (virgin) { + var sym; + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + sym = 0; + while (sym < 144) { + state.lens[sym++] = 8; + } + while (sym < 256) { + state.lens[sym++] = 9; + } + while (sym < 280) { + state.lens[sym++] = 7; + } + while (sym < 288) { + state.lens[sym++] = 8; + } + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + sym = 0; + while (sym < 32) { + state.lens[sym++] = 5; + } + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + virgin = false; + } + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; + } + function updatewindow(strm, src, end, copy) { + var dist; + var state = strm.state; + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + state.window = new utils.Buf8(state.wsize); + } + if (copy >= state.wsize) { + utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } else { + dist = state.wsize - state.wnext; + if (dist > copy) { + dist = copy; + } + utils.arraySet(state.window, src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + utils.arraySet(state.window, src, end - copy, copy, 0); + state.wnext = copy; + state.whave = state.wsize; + } else { + state.wnext += dist; + if (state.wnext === state.wsize) { + state.wnext = 0; + } + if (state.whave < state.wsize) { + state.whave += dist; + } + } + } + return 0; + } + function inflate(strm, flush) { + var state; + var input, output; + var next; + var put; + var have, left; + var hold; + var bits; + var _in, _out; + var copy; + var from; + var from_source; + var here = 0; + var here_bits, here_op, here_val; + var last_bits, last_op, last_val; + var len; + var ret; + var hbuf = new utils.Buf8(4); + var opts; + var n; + var order = ( + /* permutation of code lengths */ + [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15] + ); + if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (state.mode === TYPE) { + state.mode = TYPEDO; + } + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + _in = have; + _out = left; + ret = Z_OK; + inf_leave: + for (; ; ) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 2 && hold === 35615) { + state.check = 0; + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + hold = 0; + bits = 0; + state.mode = FLAGS; + break; + } + state.flags = 0; + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 255) << 8) + (hold >> 8)) % 31) { + strm.msg = "incorrect header check"; + state.mode = BAD; + break; + } + if ((hold & 15) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + hold >>>= 4; + bits -= 4; + len = (hold & 15) + 8; + if (state.wbits === 0) { + state.wbits = len; + } else if (len > state.wbits) { + strm.msg = "invalid window size"; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + strm.adler = state.check = 1; + state.mode = hold & 512 ? DICTID : TYPE; + hold = 0; + bits = 0; + break; + case FLAGS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.flags = hold; + if ((state.flags & 255) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + if (state.flags & 57344) { + strm.msg = "unknown header flags set"; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = hold >> 8 & 1; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = TIME; + case TIME: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.time = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + hbuf[2] = hold >>> 16 & 255; + hbuf[3] = hold >>> 24 & 255; + state.check = crc32(state.check, hbuf, 4, 0); + } + hold = 0; + bits = 0; + state.mode = OS; + case OS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.xflags = hold & 255; + state.head.os = hold >> 8; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = EXLEN; + case EXLEN: + if (state.flags & 1024) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + } else if (state.head) { + state.head.extra = null; + } + state.mode = EXTRA; + case EXTRA: + if (state.flags & 1024) { + copy = state.length; + if (copy > have) { + copy = have; + } + if (copy) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet( + state.head.extra, + input, + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + copy, + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len + ); + } + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { + break inf_leave; + } + } + state.length = 0; + state.mode = NAME; + case NAME: + if (state.flags & 2048) { + if (have === 0) { + break inf_leave; + } + copy = 0; + do { + len = input[next + copy++]; + if (state.head && len && state.length < 65536) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + case COMMENT: + if (state.flags & 4096) { + if (have === 0) { + break inf_leave; + } + copy = 0; + do { + len = input[next + copy++]; + if (state.head && len && state.length < 65536) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + case HCRC: + if (state.flags & 512) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.check & 65535)) { + strm.msg = "header crc mismatch"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + if (state.head) { + state.head.hcrc = state.flags >> 9 & 1; + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + strm.adler = state.check = zswap32(hold); + hold = 0; + bits = 0; + state.mode = DICT; + case DICT: + if (state.havedict === 0) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + return Z_NEED_DICT; + } + strm.adler = state.check = 1; + state.mode = TYPE; + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { + break inf_leave; + } + case TYPEDO: + if (state.last) { + hold >>>= bits & 7; + bits -= bits & 7; + state.mode = CHECK; + break; + } + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.last = hold & 1; + hold >>>= 1; + bits -= 1; + switch (hold & 3) { + case 0: + state.mode = STORED; + break; + case 1: + fixedtables(state); + state.mode = LEN_; + if (flush === Z_TREES) { + hold >>>= 2; + bits -= 2; + break inf_leave; + } + break; + case 2: + state.mode = TABLE; + break; + case 3: + strm.msg = "invalid block type"; + state.mode = BAD; + } + hold >>>= 2; + bits -= 2; + break; + case STORED: + hold >>>= bits & 7; + bits -= bits & 7; + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((hold & 65535) !== (hold >>> 16 ^ 65535)) { + strm.msg = "invalid stored block lengths"; + state.mode = BAD; + break; + } + state.length = hold & 65535; + hold = 0; + bits = 0; + state.mode = COPY_; + if (flush === Z_TREES) { + break inf_leave; + } + case COPY_: + state.mode = COPY; + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { + copy = have; + } + if (copy > left) { + copy = left; + } + if (copy === 0) { + break inf_leave; + } + utils.arraySet(output, input, next, copy, put); + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + break; + } + state.mode = TYPE; + break; + case TABLE: + while (bits < 14) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.nlen = (hold & 31) + 257; + hold >>>= 5; + bits -= 5; + state.ndist = (hold & 31) + 1; + hold >>>= 5; + bits -= 5; + state.ncode = (hold & 15) + 4; + hold >>>= 4; + bits -= 4; + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = "too many length or distance symbols"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = LENLENS; + case LENLENS: + while (state.have < state.ncode) { + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.lens[order[state.have++]] = hold & 7; + hold >>>= 3; + bits -= 3; + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + state.lencode = state.lendyn; + state.lenbits = 7; + opts = { bits: state.lenbits }; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid code lengths set"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = CODELENS; + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_val < 16) { + hold >>>= here_bits; + bits -= here_bits; + state.lens[state.have++] = here_val; + } else { + if (here_val === 16) { + n = here_bits + 2; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + if (state.have === 0) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy = 3 + (hold & 3); + hold >>>= 2; + bits -= 2; + } else if (here_val === 17) { + n = here_bits + 3; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len = 0; + copy = 3 + (hold & 7); + hold >>>= 3; + bits -= 3; + } else { + n = here_bits + 7; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len = 0; + copy = 11 + (hold & 127); + hold >>>= 7; + bits -= 7; + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + while (copy--) { + state.lens[state.have++] = len; + } + } + } + if (state.mode === BAD) { + break; + } + if (state.lens[256] === 0) { + strm.msg = "invalid code -- missing end-of-block"; + state.mode = BAD; + break; + } + state.lenbits = 9; + opts = { bits: state.lenbits }; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid literal/lengths set"; + state.mode = BAD; + break; + } + state.distbits = 6; + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + state.distbits = opts.bits; + if (ret) { + strm.msg = "invalid distances set"; + state.mode = BAD; + break; + } + state.mode = LEN_; + if (flush === Z_TREES) { + break inf_leave; + } + case LEN_: + state.mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + inflate_fast(strm, _out); + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_op && (here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + state.mode = LIT; + break; + } + if (here_op & 32) { + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + case LENEXT: + if (state.extra) { + n = state.extra; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + state.was = state.length; + state.mode = DIST; + case DIST: + for (; ; ) { + here = state.distcode[hold & (1 << state.distbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + if (here_op & 64) { + strm.msg = "invalid distance code"; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = here_op & 15; + state.mode = DISTEXT; + case DISTEXT: + if (state.extra) { + n = state.extra; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.offset += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + if (state.offset > state.dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + state.mode = MATCH; + case MATCH: + if (left === 0) { + break inf_leave; + } + copy = _out - left; + if (state.offset > copy) { + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } else { + from = state.wnext - copy; + } + if (copy > state.length) { + copy = state.length; + } + from_source = state.window; + } else { + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { + copy = left; + } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + if (state.length === 0) { + state.mode = LEN; + } + break; + case LIT: + if (left === 0) { + break inf_leave; + } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold |= input[next++] << bits; + bits += 8; + } + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/ + state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out); + } + _out = left; + if ((state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = "incorrect data check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = LENGTH; + case LENGTH: + if (state.wrap && state.flags) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.total & 4294967295)) { + strm.msg = "incorrect length check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = DONE; + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + } + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush !== Z_FINISH)) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ + state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if ((_in === 0 && _out === 0 || flush === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; + } + function inflateEnd(strm) { + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; + } + function inflateGetHeader(strm, head) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if ((state.wrap & 2) === 0) { + return Z_STREAM_ERROR; + } + state.head = head; + head.done = false; + return Z_OK; + } + function inflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + var state; + var dictid; + var ret; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR; + } + if (state.mode === DICT) { + dictid = 1; + dictid = adler32(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR; + } + } + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR; + } + state.havedict = 1; + return Z_OK; + } + exports.inflateReset = inflateReset; + exports.inflateReset2 = inflateReset2; + exports.inflateResetKeep = inflateResetKeep; + exports.inflateInit = inflateInit; + exports.inflateInit2 = inflateInit2; + exports.inflate = inflate; + exports.inflateEnd = inflateEnd; + exports.inflateGetHeader = inflateGetHeader; + exports.inflateSetDictionary = inflateSetDictionary; + exports.inflateInfo = "pako inflate (from Nodeca project)"; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/constants.js +var require_constants = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/constants.js"(exports, module2) { + "use strict"; + module2.exports = { + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + //Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type + }; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/gzheader.js +var require_gzheader = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/zlib/gzheader.js"(exports, module2) { + "use strict"; + function GZheader() { + this.text = 0; + this.time = 0; + this.xflags = 0; + this.os = 0; + this.extra = null; + this.extra_len = 0; + this.name = ""; + this.comment = ""; + this.hcrc = 0; + this.done = false; + } + module2.exports = GZheader; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/inflate.js +var require_inflate2 = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/lib/inflate.js"(exports) { + "use strict"; + var zlib_inflate = require_inflate(); + var utils = require_common(); + var strings = require_strings(); + var c = require_constants(); + var msg = require_messages(); + var ZStream = require_zstream(); + var GZheader = require_gzheader(); + var toString = Object.prototype.toString; + function Inflate(options) { + if (!(this instanceof Inflate)) return new Inflate(options); + this.options = utils.assign({ + chunkSize: 16384, + windowBits: 0, + to: "" + }, options || {}); + var opt = this.options; + if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) { + opt.windowBits = -opt.windowBits; + if (opt.windowBits === 0) { + opt.windowBits = -15; + } + } + if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) { + opt.windowBits += 32; + } + if (opt.windowBits > 15 && opt.windowBits < 48) { + if ((opt.windowBits & 15) === 0) { + opt.windowBits |= 15; + } + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new ZStream(); + this.strm.avail_out = 0; + var status = zlib_inflate.inflateInit2( + this.strm, + opt.windowBits + ); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + this.header = new GZheader(); + zlib_inflate.inflateGetHeader(this.strm, this.header); + if (opt.dictionary) { + if (typeof opt.dictionary === "string") { + opt.dictionary = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + opt.dictionary = new Uint8Array(opt.dictionary); + } + if (opt.raw) { + status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + } + } + } + Inflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var dictionary = this.options.dictionary; + var status, _mode; + var next_out_utf8, tail, utf8str; + var allowBufError = false; + if (this.ended) { + return false; + } + _mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH; + if (typeof data === "string") { + strm.input = strings.binstring2buf(data); + } else if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); + if (status === c.Z_NEED_DICT && dictionary) { + status = zlib_inflate.inflateSetDictionary(this.strm, dictionary); + } + if (status === c.Z_BUF_ERROR && allowBufError === true) { + status = c.Z_OK; + allowBufError = false; + } + if (status !== c.Z_STREAM_END && status !== c.Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + if (strm.next_out) { + if (strm.avail_out === 0 || status === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) { + if (this.options.to === "string") { + next_out_utf8 = strings.utf8border(strm.output, strm.next_out); + tail = strm.next_out - next_out_utf8; + utf8str = strings.buf2string(strm.output, next_out_utf8); + strm.next_out = tail; + strm.avail_out = chunkSize - tail; + if (tail) { + utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); + } + this.onData(utf8str); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } + if (strm.avail_in === 0 && strm.avail_out === 0) { + allowBufError = true; + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END); + if (status === c.Z_STREAM_END) { + _mode = c.Z_FINISH; + } + if (_mode === c.Z_FINISH) { + status = zlib_inflate.inflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === c.Z_OK; + } + if (_mode === c.Z_SYNC_FLUSH) { + this.onEnd(c.Z_OK); + strm.avail_out = 0; + return true; + } + return true; + }; + Inflate.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Inflate.prototype.onEnd = function(status) { + if (status === c.Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function inflate(input, options) { + var inflator = new Inflate(options); + inflator.push(input, true); + if (inflator.err) { + throw inflator.msg || msg[inflator.err]; + } + return inflator.result; + } + function inflateRaw(input, options) { + options = options || {}; + options.raw = true; + return inflate(input, options); + } + exports.Inflate = Inflate; + exports.inflate = inflate; + exports.inflateRaw = inflateRaw; + exports.ungzip = inflate; + } +}); + +// node_modules/.pnpm/pako@1.0.11/node_modules/pako/index.js +var require_pako = __commonJS({ + "node_modules/.pnpm/pako@1.0.11/node_modules/pako/index.js"(exports, module2) { + "use strict"; + var assign = require_common().assign; + var deflate = require_deflate2(); + var inflate = require_inflate2(); + var constants = require_constants(); + var pako5 = {}; + assign(pako5, deflate, inflate, constants); + module2.exports = pako5; + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => BetterExportPdfPlugin +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian5 = require("obsidian"); + +// src/i18n/index.ts +var import_deepmerge = __toESM(require_cjs()); + +// src/i18n/en.ts +var en_default = { + exportCurrentFile: "Export current file to PDF", + exportCurrentFileWithPrevious: "Export to PDF with previous Settings", + exportDialog: { + filenameAsTitle: "Include file name as title", + pageSize: "Page Size", + margin: "Margin", + downscalePercent: "Downscale Percent", + landscape: "Landscape", + displayHeader: "Display Header", + displayFooter: "Display Footer", + openAfterExport: "Open after export", + cssSnippets: "CSS snippets" + }, + settings: { + showTitle: "Add file name as title", + displayHeader: "Display headers", + displayFooter: "Display footer", + printBackground: "Print background", + maxLevel: "Max headings level of the outline", + displayMetadata: "PDF metadata", + headerTemplate: "Header Template", + footerTemplate: "Footer Template", + isTimestamp: "Add timestamp", + enabledCss: "Enable select css snippets", + debugMode: "Debug Mode" + } +}; + +// src/i18n/zh.ts +var zh_default = { + exportCurrentFile: "\u5BFC\u51FA\u5F53\u524D\u6587\u4EF6\u4E3APDF", + exportCurrentFileWithPrevious: "\u4F7F\u7528\u4E0A\u4E00\u6B21\u8BBE\u7F6E\u5BFC\u51FA\u4E3APDF", + exportDialog: { + filenameAsTitle: "\u5C06\u7B14\u8BB0\u540D\u4F5C\u4E3A\u6807\u9898", + pageSize: "\u7EB8\u5F20\u5C3A\u5BF8", + margin: "\u9875\u8FB9\u8DDD", + downscalePercent: "\u7F29\u653E", + landscape: "\u6A2A\u5411\u6253\u5370", + displayHeader: "\u9875\u7709", + displayFooter: "\u9875\u811A", + openAfterExport: "\u5BFC\u51FA\u540E\u6253\u5F00", + cssSnippets: "CSS\u4EE3\u7801\u7247\u6BB5" + }, + settings: { + showTitle: "\u5C06\u7B14\u8BB0\u540D\u4F5C\u4E3A\u6807\u9898", + displayHeader: "\u663E\u793A\u9875\u7709", + displayFooter: "\u663E\u793A\u9875\u811A", + printBackground: "\u6253\u5370\u80CC\u666F", + maxLevel: "\u6700\u5927\u6807\u9898\u7EA7\u522B", + displayMetadata: "PDF\u5143\u6570\u636E", + headerTemplate: "\u9875\u7709\u6A21\u677F", + footerTemplate: "\u9875\u811A\u6A21\u677F", + isTimestamp: "\u6587\u4EF6\u540D\u6DFB\u52A0\u65F6\u95F4\u6233", + enabledCss: "\u542F\u7528CSS\u7247\u6BB5\u9009\u62E9", + debugMode: "\u8C03\u8BD5\u6A21\u5F0F" + } +}; + +// src/i18n/index.ts +var i18n_default = { + i18n: { + en: en_default, + zh: zh_default + }, + get current() { + var _a, _b; + const lang = (_a = window.localStorage.getItem("language")) != null ? _a : "en"; + return (0, import_deepmerge.default)(this.i18n.en, (_b = this.i18n[lang]) != null ? _b : {}); + } +}; + +// src/modal.ts +var fs2 = __toESM(require("fs/promises")); +var import_obsidian3 = require("obsidian"); +var import_path = __toESM(require("path")); + +// src/constant.ts +var PageSize = { + A0: [841, 1189], + A1: [594, 841], + A2: [420, 594], + A3: [297, 420], + A4: [210, 297], + A5: [148, 210], + A6: [105, 148], + Legal: [216, 356], + Letter: [216, 279], + Tabloid: [279, 432], + Ledger: [432, 279] +}; + +// src/pdf.ts +var import_electron = __toESM(require("electron")); +var fs = __toESM(require("fs/promises")); + +// node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { + d2.__proto__ = b2; + } || function(d2, b2) { + for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p]; + }; + return extendStatics(d, b); +}; +function __extends(d, b) { + extendStatics(d, b); + function __() { + this.constructor = d; + } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} +var __assign = function() { + __assign = Object.assign || function __assign2(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +function __rest(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +} +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { + if (t[0] & 1) throw t[1]; + return t[1]; + }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { + return this; + }), g; + function verb(n) { + return function(v) { + return step([n, v]); + }; + } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: + case 1: + t = op; + break; + case 4: + _.label++; + return { value: op[1], done: false }; + case 5: + _.label++; + y = op[1]; + op = [0]; + continue; + case 7: + op = _.ops.pop(); + _.trys.pop(); + continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { + _ = 0; + continue; + } + if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { + _.label = op[1]; + break; + } + if (op[0] === 6 && _.label < t[1]) { + _.label = t[1]; + t = op; + break; + } + if (t && _.label < t[2]) { + _.label = t[2]; + _.ops.push(op); + break; + } + if (t[2]) _.ops.pop(); + _.trys.pop(); + continue; + } + op = body.call(thisArg, _); + } catch (e) { + op = [6, e]; + y = 0; + } finally { + f = t = 0; + } + if (op[0] & 5) throw op[1]; + return { value: op[0] ? op[1] : void 0, done: true }; + } +} +function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +} + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/base64.js +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var lookup = new Uint8Array(256); +for (i = 0; i < chars.length; i++) { + lookup[chars.charCodeAt(i)] = i; +} +var i; +var encodeToBase64 = function(bytes) { + var base64 = ""; + var len = bytes.length; + for (var i = 0; i < len; i += 3) { + base64 += chars[bytes[i] >> 2]; + base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4]; + base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6]; + base64 += chars[bytes[i + 2] & 63]; + } + if (len % 3 === 2) { + base64 = base64.substring(0, base64.length - 1) + "="; + } else if (len % 3 === 1) { + base64 = base64.substring(0, base64.length - 2) + "=="; + } + return base64; +}; +var decodeFromBase64 = function(base64) { + var bufferLength = base64.length * 0.75; + var len = base64.length; + var i; + var p = 0; + var encoded1; + var encoded2; + var encoded3; + var encoded4; + if (base64[base64.length - 1] === "=") { + bufferLength--; + if (base64[base64.length - 2] === "=") { + bufferLength--; + } + } + var bytes = new Uint8Array(bufferLength); + for (i = 0; i < len; i += 4) { + encoded1 = lookup[base64.charCodeAt(i)]; + encoded2 = lookup[base64.charCodeAt(i + 1)]; + encoded3 = lookup[base64.charCodeAt(i + 2)]; + encoded4 = lookup[base64.charCodeAt(i + 3)]; + bytes[p++] = encoded1 << 2 | encoded2 >> 4; + bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; + } + return bytes; +}; +var DATA_URI_PREFIX_REGEX = /^(data)?:?([\w\/\+]+)?;?(charset=[\w-]+|base64)?.*,/i; +var decodeFromBase64DataUri = function(dataUri) { + var trimmedUri = dataUri.trim(); + var prefix = trimmedUri.substring(0, 100); + var res = prefix.match(DATA_URI_PREFIX_REGEX); + if (!res) + return decodeFromBase64(trimmedUri); + var fullMatch = res[0]; + var data = trimmedUri.substring(fullMatch.length); + return decodeFromBase64(data); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/strings.js +var toCharCode = function(character) { + return character.charCodeAt(0); +}; +var toCodePoint = function(character) { + return character.codePointAt(0); +}; +var toHexStringOfMinLength = function(num, minLength) { + return padStart(num.toString(16), minLength, "0").toUpperCase(); +}; +var toHexString = function(num) { + return toHexStringOfMinLength(num, 2); +}; +var charFromCode = function(code) { + return String.fromCharCode(code); +}; +var charFromHexCode = function(hex) { + return charFromCode(parseInt(hex, 16)); +}; +var padStart = function(value, length, padChar) { + var padding = ""; + for (var idx = 0, len = length - value.length; idx < len; idx++) { + padding += padChar; + } + return padding + value; +}; +var copyStringIntoBuffer = function(str, buffer, offset) { + var length = str.length; + for (var idx = 0; idx < length; idx++) { + buffer[offset++] = str.charCodeAt(idx); + } + return length; +}; +var escapeRegExp = function(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +}; +var cleanText = function(text) { + return text.replace(/\t|\u0085|\u2028|\u2029/g, " ").replace(/[\b\v]/g, ""); +}; +var escapedNewlineChars = ["\\n", "\\f", "\\r", "\\u000B"]; +var isNewlineChar = function(text) { + return /^[\n\f\r\u000B]$/.test(text); +}; +var lineSplit = function(text) { + return text.split(/[\n\f\r\u000B]/); +}; +var mergeLines = function(text) { + return text.replace(/[\n\f\r\u000B]/g, " "); +}; +var charAtIndex = function(text, index) { + var cuFirst = text.charCodeAt(index); + var cuSecond; + var nextIndex = index + 1; + var length = 1; + if ( + // Check if it's the start of a surrogate pair. + cuFirst >= 55296 && cuFirst <= 56319 && // high surrogate + text.length > nextIndex + ) { + cuSecond = text.charCodeAt(nextIndex); + if (cuSecond >= 56320 && cuSecond <= 57343) + length = 2; + } + return [text.slice(index, index + length), length]; +}; +var charSplit = function(text) { + var chars3 = []; + for (var idx = 0, len = text.length; idx < len; ) { + var _a = charAtIndex(text, idx), c = _a[0], cLen = _a[1]; + chars3.push(c); + idx += cLen; + } + return chars3; +}; +var buildWordBreakRegex = function(wordBreaks) { + var newlineCharUnion = escapedNewlineChars.join("|"); + var escapedRules = ["$"]; + for (var idx = 0, len = wordBreaks.length; idx < len; idx++) { + var wordBreak = wordBreaks[idx]; + if (isNewlineChar(wordBreak)) { + throw new TypeError("`wordBreak` must not include " + newlineCharUnion); + } + escapedRules.push(wordBreak === "" ? "." : escapeRegExp(wordBreak)); + } + var breakRules = escapedRules.join("|"); + return new RegExp("(" + newlineCharUnion + ")|((.*?)(" + breakRules + "))", "gm"); +}; +var breakTextIntoLines = function(text, wordBreaks, maxWidth, computeWidthOfText) { + var regex = buildWordBreakRegex(wordBreaks); + var words = cleanText(text).match(regex); + var currLine = ""; + var currWidth = 0; + var lines = []; + var pushCurrLine = function() { + if (currLine !== "") + lines.push(currLine); + currLine = ""; + currWidth = 0; + }; + for (var idx = 0, len = words.length; idx < len; idx++) { + var word = words[idx]; + if (isNewlineChar(word)) { + pushCurrLine(); + } else { + var width = computeWidthOfText(word); + if (currWidth + width > maxWidth) + pushCurrLine(); + currLine += word; + currWidth += width; + } + } + pushCurrLine(); + return lines; +}; +var dateRegex = /^D:(\d\d\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([+\-Z])?(\d\d)?'?(\d\d)?'?$/; +var parseDate = function(dateStr) { + var match = dateStr.match(dateRegex); + if (!match) + return void 0; + var year = match[1], _a = match[2], month = _a === void 0 ? "01" : _a, _b = match[3], day = _b === void 0 ? "01" : _b, _c = match[4], hours = _c === void 0 ? "00" : _c, _d = match[5], mins = _d === void 0 ? "00" : _d, _e = match[6], secs = _e === void 0 ? "00" : _e, _f = match[7], offsetSign = _f === void 0 ? "Z" : _f, _g = match[8], offsetHours = _g === void 0 ? "00" : _g, _h = match[9], offsetMins = _h === void 0 ? "00" : _h; + var tzOffset = offsetSign === "Z" ? "Z" : "" + offsetSign + offsetHours + ":" + offsetMins; + var date = /* @__PURE__ */ new Date(year + "-" + month + "-" + day + "T" + hours + ":" + mins + ":" + secs + tzOffset); + return date; +}; +var findLastMatch = function(value, regex) { + var _a; + var position = 0; + var lastMatch; + while (position < value.length) { + var match = value.substring(position).match(regex); + if (!match) + return { match: lastMatch, pos: position }; + lastMatch = match; + position += ((_a = match.index) !== null && _a !== void 0 ? _a : 0) + match[0].length; + } + return { match: lastMatch, pos: position }; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/arrays.js +var last = function(array) { + return array[array.length - 1]; +}; +var typedArrayFor = function(value) { + if (value instanceof Uint8Array) + return value; + var length = value.length; + var typedArray = new Uint8Array(length); + for (var idx = 0; idx < length; idx++) { + typedArray[idx] = value.charCodeAt(idx); + } + return typedArray; +}; +var mergeIntoTypedArray = function() { + var arrays = []; + for (var _i = 0; _i < arguments.length; _i++) { + arrays[_i] = arguments[_i]; + } + var arrayCount = arrays.length; + var typedArrays = []; + for (var idx = 0; idx < arrayCount; idx++) { + var element = arrays[idx]; + typedArrays[idx] = element instanceof Uint8Array ? element : typedArrayFor(element); + } + var totalSize = 0; + for (var idx = 0; idx < arrayCount; idx++) { + totalSize += arrays[idx].length; + } + var merged = new Uint8Array(totalSize); + var offset = 0; + for (var arrIdx = 0; arrIdx < arrayCount; arrIdx++) { + var arr = typedArrays[arrIdx]; + for (var byteIdx = 0, arrLen = arr.length; byteIdx < arrLen; byteIdx++) { + merged[offset++] = arr[byteIdx]; + } + } + return merged; +}; +var mergeUint8Arrays = function(arrays) { + var totalSize = 0; + for (var idx = 0, len = arrays.length; idx < len; idx++) { + totalSize += arrays[idx].length; + } + var mergedBuffer = new Uint8Array(totalSize); + var offset = 0; + for (var idx = 0, len = arrays.length; idx < len; idx++) { + var array = arrays[idx]; + mergedBuffer.set(array, offset); + offset += array.length; + } + return mergedBuffer; +}; +var arrayAsString = function(array) { + var str = ""; + for (var idx = 0, len = array.length; idx < len; idx++) { + str += charFromCode(array[idx]); + } + return str; +}; +var byAscendingId = function(a, b) { + return a.id - b.id; +}; +var sortedUniq = function(array, indexer) { + var uniq = []; + for (var idx = 0, len = array.length; idx < len; idx++) { + var curr = array[idx]; + var prev = array[idx - 1]; + if (idx === 0 || indexer(curr) !== indexer(prev)) { + uniq.push(curr); + } + } + return uniq; +}; +var reverseArray = function(array) { + var arrayLen = array.length; + for (var idx = 0, len = Math.floor(arrayLen / 2); idx < len; idx++) { + var leftIdx = idx; + var rightIdx = arrayLen - idx - 1; + var temp = array[idx]; + array[leftIdx] = array[rightIdx]; + array[rightIdx] = temp; + } + return array; +}; +var sum = function(array) { + var total = 0; + for (var idx = 0, len = array.length; idx < len; idx++) { + total += array[idx]; + } + return total; +}; +var range = function(start, end) { + var arr = new Array(end - start); + for (var idx = 0, len = arr.length; idx < len; idx++) { + arr[idx] = start + idx; + } + return arr; +}; +var pluckIndices = function(arr, indices) { + var plucked = new Array(indices.length); + for (var idx = 0, len = indices.length; idx < len; idx++) { + plucked[idx] = arr[indices[idx]]; + } + return plucked; +}; +var canBeConvertedToUint8Array = function(input) { + return input instanceof Uint8Array || input instanceof ArrayBuffer || typeof input === "string"; +}; +var toUint8Array = function(input) { + if (typeof input === "string") { + return decodeFromBase64DataUri(input); + } else if (input instanceof ArrayBuffer) { + return new Uint8Array(input); + } else if (input instanceof Uint8Array) { + return input; + } else { + throw new TypeError("`input` must be one of `string | ArrayBuffer | Uint8Array`"); + } +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/async.js +var waitForTick = function() { + return new Promise(function(resolve) { + setTimeout(function() { + return resolve(); + }, 0); + }); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/unicode.js +var utf16Encode = function(input, byteOrderMark) { + if (byteOrderMark === void 0) { + byteOrderMark = true; + } + var encoded = []; + if (byteOrderMark) + encoded.push(65279); + for (var idx = 0, len = input.length; idx < len; ) { + var codePoint = input.codePointAt(idx); + if (codePoint < 65536) { + encoded.push(codePoint); + idx += 1; + } else if (codePoint < 1114112) { + encoded.push(highSurrogate(codePoint), lowSurrogate(codePoint)); + idx += 2; + } else + throw new Error("Invalid code point: 0x" + toHexString(codePoint)); + } + return new Uint16Array(encoded); +}; +var isWithinBMP = function(codePoint) { + return codePoint >= 0 && codePoint <= 65535; +}; +var hasSurrogates = function(codePoint) { + return codePoint >= 65536 && codePoint <= 1114111; +}; +var highSurrogate = function(codePoint) { + return Math.floor((codePoint - 65536) / 1024) + 55296; +}; +var lowSurrogate = function(codePoint) { + return (codePoint - 65536) % 1024 + 56320; +}; +var ByteOrder; +(function(ByteOrder2) { + ByteOrder2["BigEndian"] = "BigEndian"; + ByteOrder2["LittleEndian"] = "LittleEndian"; +})(ByteOrder || (ByteOrder = {})); +var REPLACEMENT = "\uFFFD".codePointAt(0); +var utf16Decode = function(input, byteOrderMark) { + if (byteOrderMark === void 0) { + byteOrderMark = true; + } + if (input.length <= 1) + return String.fromCodePoint(REPLACEMENT); + var byteOrder = byteOrderMark ? readBOM(input) : ByteOrder.BigEndian; + var idx = byteOrderMark ? 2 : 0; + var codePoints = []; + while (input.length - idx >= 2) { + var first = decodeValues(input[idx++], input[idx++], byteOrder); + if (isHighSurrogate(first)) { + if (input.length - idx < 2) { + codePoints.push(REPLACEMENT); + } else { + var second = decodeValues(input[idx++], input[idx++], byteOrder); + if (isLowSurrogate(second)) { + codePoints.push(first, second); + } else { + codePoints.push(REPLACEMENT); + } + } + } else if (isLowSurrogate(first)) { + idx += 2; + codePoints.push(REPLACEMENT); + } else { + codePoints.push(first); + } + } + if (idx < input.length) + codePoints.push(REPLACEMENT); + return String.fromCodePoint.apply(String, codePoints); +}; +var isHighSurrogate = function(codePoint) { + return codePoint >= 55296 && codePoint <= 56319; +}; +var isLowSurrogate = function(codePoint) { + return codePoint >= 56320 && codePoint <= 57343; +}; +var decodeValues = function(first, second, byteOrder) { + if (byteOrder === ByteOrder.LittleEndian) + return second << 8 | first; + if (byteOrder === ByteOrder.BigEndian) + return first << 8 | second; + throw new Error("Invalid byteOrder: " + byteOrder); +}; +var readBOM = function(bytes) { + return hasUtf16BigEndianBOM(bytes) ? ByteOrder.BigEndian : hasUtf16LittleEndianBOM(bytes) ? ByteOrder.LittleEndian : ByteOrder.BigEndian; +}; +var hasUtf16BigEndianBOM = function(bytes) { + return bytes[0] === 254 && bytes[1] === 255; +}; +var hasUtf16LittleEndianBOM = function(bytes) { + return bytes[0] === 255 && bytes[1] === 254; +}; +var hasUtf16BOM = function(bytes) { + return hasUtf16BigEndianBOM(bytes) || hasUtf16LittleEndianBOM(bytes); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/numbers.js +var numberToString = function(num) { + var numStr = String(num); + if (Math.abs(num) < 1) { + var e = parseInt(num.toString().split("e-")[1]); + if (e) { + var negative = num < 0; + if (negative) + num *= -1; + num *= Math.pow(10, e - 1); + numStr = "0." + new Array(e).join("0") + num.toString().substring(2); + if (negative) + numStr = "-" + numStr; + } + } else { + var e = parseInt(num.toString().split("+")[1]); + if (e > 20) { + e -= 20; + num /= Math.pow(10, e); + numStr = num.toString() + new Array(e + 1).join("0"); + } + } + return numStr; +}; +var sizeInBytes = function(n) { + return Math.ceil(n.toString(2).length / 8); +}; +var bytesFor = function(n) { + var bytes = new Uint8Array(sizeInBytes(n)); + for (var i = 1; i <= bytes.length; i++) { + bytes[i - 1] = n >> (bytes.length - i) * 8; + } + return bytes; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/errors.js +var error = function(msg) { + throw new Error(msg); +}; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/utils.js +var import_pako = __toESM(require_pako()); +var chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var lookup2 = new Uint8Array(256); +for (i = 0; i < chars2.length; i++) { + lookup2[chars2.charCodeAt(i)] = i; +} +var i; +var decodeFromBase642 = function(base64) { + var bufferLength = base64.length * 0.75; + var len = base64.length; + var i; + var p = 0; + var encoded1; + var encoded2; + var encoded3; + var encoded4; + if (base64[base64.length - 1] === "=") { + bufferLength--; + if (base64[base64.length - 2] === "=") { + bufferLength--; + } + } + var bytes = new Uint8Array(bufferLength); + for (i = 0; i < len; i += 4) { + encoded1 = lookup2[base64.charCodeAt(i)]; + encoded2 = lookup2[base64.charCodeAt(i + 1)]; + encoded3 = lookup2[base64.charCodeAt(i + 2)]; + encoded4 = lookup2[base64.charCodeAt(i + 3)]; + bytes[p++] = encoded1 << 2 | encoded2 >> 4; + bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; + } + return bytes; +}; +var arrayToString = function(array) { + var str = ""; + for (var i = 0; i < array.length; i++) { + str += String.fromCharCode(array[i]); + } + return str; +}; +var decompressJson = function(compressedJson) { + return arrayToString(import_pako.default.inflate(decodeFromBase642(compressedJson))); +}; +var padStart2 = function(value, length, padChar) { + var padding = ""; + for (var idx = 0, len = length - value.length; idx < len; idx++) { + padding += padChar; + } + return padding + value; +}; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Courier-Bold.compressed.json +var Courier_Bold_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Courier-BoldOblique.compressed.json +var Courier_BoldOblique_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Courier-Oblique.compressed.json +var Courier_Oblique_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Courier.compressed.json +var Courier_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Helvetica-Bold.compressed.json +var Helvetica_Bold_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Helvetica-BoldOblique.compressed.json +var Helvetica_BoldOblique_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Helvetica-Oblique.compressed.json +var Helvetica_Oblique_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Helvetica.compressed.json +var Helvetica_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Times-Bold.compressed.json +var Times_Bold_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Times-BoldItalic.compressed.json +var Times_BoldItalic_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Times-Italic.compressed.json +var Times_Italic_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Times-Roman.compressed.json +var Times_Roman_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Symbol.compressed.json +var Symbol_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/ZapfDingbats.compressed.json +var ZapfDingbats_compressed_default = "eJxtmNtu20YQhl+F4FULyMGeD7pz3AY1ChtG7NpFA18w1NomIlECSRcxgrx7SVk7+wOdG8H5OJydf2Z2d5gf9cV+t0v9VK/r+6vXsXlOlbHe28paq229qj/t++m62aXZ4J/m8PRb1z9/baZxefK63Z6eXN5dVMvTCh83u277xr/6kLrnl2XNq7TpXnczuZyabdee98/b2VzM/x4/dd/T5qab2pd6PQ2vaVVfvDRD005puE3Lu7eH1HbN9hTjx4/77/X6y5lcnUmjVzHIVVDicVX/1W/SsO36dLMfu6nb9/X6TAoBD+5euvZbn8axXtuZ36dhPJrVQqgPQoh5hev91LWLkIv94W1Ygq9+aX+tZAx2tfz64284/sblN/rqfLP/mqrbt3FKu7G67Nv9cNgPzZQ2H6rz7bb6vLgZq89pTMO/M/xfEqturJpqSM/d7GJIm2oamk3aNcO3av80O5xh3yyKmm1193ZIT02bqovTKjP+MAf++7zsZvZ3276kYyWWXB0z99S18/PbafPHQ71W4fjn/fxnFO+ZvkrT0LVzTr78qB/+nk38bHM9exgP8zr1z9U7jt6840YW5uSJKcZOCaBBnKgm5mU8MVNYyMwWFvO7Ukagkmgg6sDWQ5yFFqjzUrLEaQ3BEmiwNsMSaZS0vgWfOkPHWQowNeTUc0kumnxZvsgPxlGai6VTGUqAVCTQ6QkWnc77DKEiLktSUBJKqHIQZ86d8gCpHYoiEzMsb1ubYy8vW50DChB5ZhGqrijD0EqUIeiaEHIfCg5Kpuu0ApiToaGPSY0uaQsyr65L2oKi1yFt1PLaQ3lzfXTgXodGoJYzglndSLDMPg1sTPJpQJHJigw0QrGERqD9YhyTOgONQDUyuF1zaxuokc/BW2ztXCMrGZ9WMW1oQZHIXWNBkSCfRZEL5BMUiZw6CzVSFCfUSGZFNjIldoKDkonTKQiJIGzWmFd3BizJJ9SINoLDriOfUCOZS+zg+KGD1qGiLNMLxtJD1/ns00ON6EzyUCM6vbxhoBKaqbG3DFQCNiL1iHccBPV0DHhQH/JW8EW90dkyFKGywCJU0WkVSvSGeiSUODWFFD0HYdPQVoiRgfPMA+/nnRgiAyNYSjpWNQcNSMrtFCUH4ZIRpSCWocFCSuhCEY6hoUClc0WC52BJlCYYLQdhN+hygRRRlo5BKRRLS6oihSqh+ZzzRGG1Mo4Iz1LoP0qsxDGFzk0JE42ji0jCPejomJKCuwil4m5CiRMEUMVSzVLDUstSx1Juc0oVWMpqY295qVltmtWmWW2a1aZZbZrVplltmtWmWW2G1WZYbYbVZlhthtVmWG2G1WZYbYbVZlhtltVmWW2W1WZZbZbVZlltltVmWW2W1QYjQCh7E2aAQHeGhCFgPoNoy8KNb2wxBhmGKBxoUZXlLGsLI6AsftEDHV0wIURVbANLcTKlGGBIKPOAxCmhePCKUwFzAmpDFRQvjA9R06Hq8TONvshgKDCuRAZTXigUxjxNFfKRo3CLhnIJBMFRvMZpqpNBMlQJzGT5WFQMVQI/AikPMIhEU1aDjqJvQwmjSHB05cC9jbYwc5UtAHNLhDw41ha+lEqF4JaH3gmB61SYcqInxTDmQK8v08vjqv4zDf1N0w3Lf4A8/vwPpfK11w=="; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Font.js +var compressedJsonForFontName = { + "Courier": Courier_compressed_default, + "Courier-Bold": Courier_Bold_compressed_default, + "Courier-Oblique": Courier_Oblique_compressed_default, + "Courier-BoldOblique": Courier_BoldOblique_compressed_default, + "Helvetica": Helvetica_compressed_default, + "Helvetica-Bold": Helvetica_Bold_compressed_default, + "Helvetica-Oblique": Helvetica_Oblique_compressed_default, + "Helvetica-BoldOblique": Helvetica_BoldOblique_compressed_default, + "Times-Roman": Times_Roman_compressed_default, + "Times-Bold": Times_Bold_compressed_default, + "Times-Italic": Times_Italic_compressed_default, + "Times-BoldItalic": Times_BoldItalic_compressed_default, + "Symbol": Symbol_compressed_default, + "ZapfDingbats": ZapfDingbats_compressed_default +}; +var FontNames; +(function(FontNames2) { + FontNames2["Courier"] = "Courier"; + FontNames2["CourierBold"] = "Courier-Bold"; + FontNames2["CourierOblique"] = "Courier-Oblique"; + FontNames2["CourierBoldOblique"] = "Courier-BoldOblique"; + FontNames2["Helvetica"] = "Helvetica"; + FontNames2["HelveticaBold"] = "Helvetica-Bold"; + FontNames2["HelveticaOblique"] = "Helvetica-Oblique"; + FontNames2["HelveticaBoldOblique"] = "Helvetica-BoldOblique"; + FontNames2["TimesRoman"] = "Times-Roman"; + FontNames2["TimesRomanBold"] = "Times-Bold"; + FontNames2["TimesRomanItalic"] = "Times-Italic"; + FontNames2["TimesRomanBoldItalic"] = "Times-BoldItalic"; + FontNames2["Symbol"] = "Symbol"; + FontNames2["ZapfDingbats"] = "ZapfDingbats"; +})(FontNames || (FontNames = {})); +var fontCache = {}; +var Font = ( + /** @class */ + function() { + function Font2() { + var _this = this; + this.getWidthOfGlyph = function(glyphName) { + return _this.CharWidths[glyphName]; + }; + this.getXAxisKerningForPair = function(leftGlyphName, rightGlyphName) { + return (_this.KernPairXAmounts[leftGlyphName] || {})[rightGlyphName]; + }; + } + Font2.load = function(fontName) { + var cachedFont = fontCache[fontName]; + if (cachedFont) + return cachedFont; + var json = decompressJson(compressedJsonForFontName[fontName]); + var font = Object.assign(new Font2(), JSON.parse(json)); + font.CharWidths = font.CharMetrics.reduce(function(acc, metric) { + acc[metric.N] = metric.WX; + return acc; + }, {}); + font.KernPairXAmounts = font.KernPairs.reduce(function(acc, _a) { + var name1 = _a[0], name2 = _a[1], width = _a[2]; + if (!acc[name1]) + acc[name1] = {}; + acc[name1][name2] = width; + return acc; + }, {}); + fontCache[fontName] = font; + return font; + }; + return Font2; + }() +); + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/all-encodings.compressed.json +var all_encodings_compressed_default = "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"; + +// node_modules/.pnpm/@pdf-lib+standard-fonts@1.0.0/node_modules/@pdf-lib/standard-fonts/es/Encoding.js +var decompressedEncodings = decompressJson(all_encodings_compressed_default); +var allUnicodeMappings = JSON.parse(decompressedEncodings); +var Encoding = ( + /** @class */ + /* @__PURE__ */ function() { + function Encoding2(name, unicodeMappings) { + var _this = this; + this.canEncodeUnicodeCodePoint = function(codePoint) { + return codePoint in _this.unicodeMappings; + }; + this.encodeUnicodeCodePoint = function(codePoint) { + var mapped = _this.unicodeMappings[codePoint]; + if (!mapped) { + var str = String.fromCharCode(codePoint); + var hexCode = "0x" + padStart2(codePoint.toString(16), 4, "0"); + var msg = _this.name + ' cannot encode "' + str + '" (' + hexCode + ")"; + throw new Error(msg); + } + return { code: mapped[0], name: mapped[1] }; + }; + this.name = name; + this.supportedCodePoints = Object.keys(unicodeMappings).map(Number).sort(function(a, b) { + return a - b; + }); + this.unicodeMappings = unicodeMappings; + } + return Encoding2; + }() +); +var Encodings = { + Symbol: new Encoding("Symbol", allUnicodeMappings.symbol), + ZapfDingbats: new Encoding("ZapfDingbats", allUnicodeMappings.zapfdingbats), + WinAnsi: new Encoding("WinAnsi", allUnicodeMappings.win1252) +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/objects.js +var values = function(obj) { + return Object.keys(obj).map(function(k) { + return obj[k]; + }); +}; +var StandardFontValues = values(FontNames); +var isStandardFont = function(input) { + return StandardFontValues.includes(input); +}; +var rectanglesAreEqual = function(a, b) { + return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/validators.js +var backtick = function(val) { + return "`" + val + "`"; +}; +var singleQuote = function(val) { + return "'" + val + "'"; +}; +var formatValue = function(value) { + var type = typeof value; + if (type === "string") + return singleQuote(value); + else if (type === "undefined") + return backtick(value); + else + return value; +}; +var createValueErrorMsg = function(value, valueName, values2) { + var allowedValues = new Array(values2.length); + for (var idx = 0, len = values2.length; idx < len; idx++) { + var v = values2[idx]; + allowedValues[idx] = formatValue(v); + } + var joinedValues = allowedValues.join(" or "); + return backtick(valueName) + " must be one of " + joinedValues + ", but was actually " + formatValue(value); +}; +var assertIsOneOf = function(value, valueName, allowedValues) { + if (!Array.isArray(allowedValues)) { + allowedValues = values(allowedValues); + } + for (var idx = 0, len = allowedValues.length; idx < len; idx++) { + if (value === allowedValues[idx]) + return; + } + throw new TypeError(createValueErrorMsg(value, valueName, allowedValues)); +}; +var assertIsOneOfOrUndefined = function(value, valueName, allowedValues) { + if (!Array.isArray(allowedValues)) { + allowedValues = values(allowedValues); + } + assertIsOneOf(value, valueName, allowedValues.concat(void 0)); +}; +var assertIsSubset = function(values2, valueName, allowedValues) { + if (!Array.isArray(allowedValues)) { + allowedValues = values(allowedValues); + } + for (var idx = 0, len = values2.length; idx < len; idx++) { + assertIsOneOf(values2[idx], valueName, allowedValues); + } +}; +var getType = function(val) { + if (val === null) + return "null"; + if (val === void 0) + return "undefined"; + if (typeof val === "string") + return "string"; + if (isNaN(val)) + return "NaN"; + if (typeof val === "number") + return "number"; + if (typeof val === "boolean") + return "boolean"; + if (typeof val === "symbol") + return "symbol"; + if (typeof val === "bigint") + return "bigint"; + if (val.constructor && val.constructor.name) + return val.constructor.name; + if (val.name) + return val.name; + if (val.constructor) + return String(val.constructor); + return String(val); +}; +var isType = function(value, type) { + if (type === "null") + return value === null; + if (type === "undefined") + return value === void 0; + if (type === "string") + return typeof value === "string"; + if (type === "number") + return typeof value === "number" && !isNaN(value); + if (type === "boolean") + return typeof value === "boolean"; + if (type === "symbol") + return typeof value === "symbol"; + if (type === "bigint") + return typeof value === "bigint"; + if (type === Date) + return value instanceof Date; + if (type === Array) + return value instanceof Array; + if (type === Uint8Array) + return value instanceof Uint8Array; + if (type === ArrayBuffer) + return value instanceof ArrayBuffer; + if (type === Function) + return value instanceof Function; + return value instanceof type[0]; +}; +var createTypeErrorMsg = function(value, valueName, types) { + var allowedTypes = new Array(types.length); + for (var idx = 0, len = types.length; idx < len; idx++) { + var type = types[idx]; + if (type === "null") + allowedTypes[idx] = backtick("null"); + if (type === "undefined") + allowedTypes[idx] = backtick("undefined"); + if (type === "string") + allowedTypes[idx] = backtick("string"); + else if (type === "number") + allowedTypes[idx] = backtick("number"); + else if (type === "boolean") + allowedTypes[idx] = backtick("boolean"); + else if (type === "symbol") + allowedTypes[idx] = backtick("symbol"); + else if (type === "bigint") + allowedTypes[idx] = backtick("bigint"); + else if (type === Array) + allowedTypes[idx] = backtick("Array"); + else if (type === Uint8Array) + allowedTypes[idx] = backtick("Uint8Array"); + else if (type === ArrayBuffer) + allowedTypes[idx] = backtick("ArrayBuffer"); + else + allowedTypes[idx] = backtick(type[1]); + } + var joinedTypes = allowedTypes.join(" or "); + return backtick(valueName) + " must be of type " + joinedTypes + ", but was actually of type " + backtick(getType(value)); +}; +var assertIs = function(value, valueName, types) { + for (var idx = 0, len = types.length; idx < len; idx++) { + if (isType(value, types[idx])) + return; + } + throw new TypeError(createTypeErrorMsg(value, valueName, types)); +}; +var assertOrUndefined = function(value, valueName, types) { + assertIs(value, valueName, types.concat("undefined")); +}; +var assertEachIs = function(values2, valueName, types) { + for (var idx = 0, len = values2.length; idx < len; idx++) { + assertIs(values2[idx], valueName, types); + } +}; +var assertRange = function(value, valueName, min, max) { + assertIs(value, valueName, ["number"]); + assertIs(min, "min", ["number"]); + assertIs(max, "max", ["number"]); + max = Math.max(min, max); + if (value < min || value > max) { + throw new Error(backtick(valueName) + " must be at least " + min + " and at most " + max + ", but was actually " + value); + } +}; +var assertRangeOrUndefined = function(value, valueName, min, max) { + assertIs(value, valueName, ["number", "undefined"]); + if (typeof value === "number") + assertRange(value, valueName, min, max); +}; +var assertMultiple = function(value, valueName, multiplier) { + assertIs(value, valueName, ["number"]); + if (value % multiplier !== 0) { + throw new Error(backtick(valueName) + " must be a multiple of " + multiplier + ", but was actually " + value); + } +}; +var assertInteger = function(value, valueName) { + if (!Number.isInteger(value)) { + throw new Error(backtick(valueName) + " must be an integer, but was actually " + value); + } +}; +var assertPositive = function(value, valueName) { + if (![1, 0].includes(Math.sign(value))) { + throw new Error(backtick(valueName) + " must be a positive number or 0, but was actually " + value); + } +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/pdfDocEncoding.js +var pdfDocEncodingToUnicode = new Uint16Array(256); +for (idx = 0; idx < 256; idx++) { + pdfDocEncodingToUnicode[idx] = idx; +} +var idx; +pdfDocEncodingToUnicode[22] = toCharCode(""); +pdfDocEncodingToUnicode[24] = toCharCode("\u02D8"); +pdfDocEncodingToUnicode[25] = toCharCode("\u02C7"); +pdfDocEncodingToUnicode[26] = toCharCode("\u02C6"); +pdfDocEncodingToUnicode[27] = toCharCode("\u02D9"); +pdfDocEncodingToUnicode[28] = toCharCode("\u02DD"); +pdfDocEncodingToUnicode[29] = toCharCode("\u02DB"); +pdfDocEncodingToUnicode[30] = toCharCode("\u02DA"); +pdfDocEncodingToUnicode[31] = toCharCode("\u02DC"); +pdfDocEncodingToUnicode[127] = toCharCode("\uFFFD"); +pdfDocEncodingToUnicode[128] = toCharCode("\u2022"); +pdfDocEncodingToUnicode[129] = toCharCode("\u2020"); +pdfDocEncodingToUnicode[130] = toCharCode("\u2021"); +pdfDocEncodingToUnicode[131] = toCharCode("\u2026"); +pdfDocEncodingToUnicode[132] = toCharCode("\u2014"); +pdfDocEncodingToUnicode[133] = toCharCode("\u2013"); +pdfDocEncodingToUnicode[134] = toCharCode("\u0192"); +pdfDocEncodingToUnicode[135] = toCharCode("\u2044"); +pdfDocEncodingToUnicode[136] = toCharCode("\u2039"); +pdfDocEncodingToUnicode[137] = toCharCode("\u203A"); +pdfDocEncodingToUnicode[138] = toCharCode("\u2212"); +pdfDocEncodingToUnicode[139] = toCharCode("\u2030"); +pdfDocEncodingToUnicode[140] = toCharCode("\u201E"); +pdfDocEncodingToUnicode[141] = toCharCode("\u201C"); +pdfDocEncodingToUnicode[142] = toCharCode("\u201D"); +pdfDocEncodingToUnicode[143] = toCharCode("\u2018"); +pdfDocEncodingToUnicode[144] = toCharCode("\u2019"); +pdfDocEncodingToUnicode[145] = toCharCode("\u201A"); +pdfDocEncodingToUnicode[146] = toCharCode("\u2122"); +pdfDocEncodingToUnicode[147] = toCharCode("\uFB01"); +pdfDocEncodingToUnicode[148] = toCharCode("\uFB02"); +pdfDocEncodingToUnicode[149] = toCharCode("\u0141"); +pdfDocEncodingToUnicode[150] = toCharCode("\u0152"); +pdfDocEncodingToUnicode[151] = toCharCode("\u0160"); +pdfDocEncodingToUnicode[152] = toCharCode("\u0178"); +pdfDocEncodingToUnicode[153] = toCharCode("\u017D"); +pdfDocEncodingToUnicode[154] = toCharCode("\u0131"); +pdfDocEncodingToUnicode[155] = toCharCode("\u0142"); +pdfDocEncodingToUnicode[156] = toCharCode("\u0153"); +pdfDocEncodingToUnicode[157] = toCharCode("\u0161"); +pdfDocEncodingToUnicode[158] = toCharCode("\u017E"); +pdfDocEncodingToUnicode[159] = toCharCode("\uFFFD"); +pdfDocEncodingToUnicode[160] = toCharCode("\u20AC"); +pdfDocEncodingToUnicode[173] = toCharCode("\uFFFD"); +var pdfDocEncodingDecode = function(bytes) { + var codePoints = new Array(bytes.length); + for (var idx = 0, len = bytes.length; idx < len; idx++) { + codePoints[idx] = pdfDocEncodingToUnicode[bytes[idx]]; + } + return String.fromCodePoint.apply(String, codePoints); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/Cache.js +var Cache = ( + /** @class */ + function() { + function Cache2(populate) { + this.populate = populate; + this.value = void 0; + } + Cache2.prototype.getValue = function() { + return this.value; + }; + Cache2.prototype.access = function() { + if (!this.value) + this.value = this.populate(); + return this.value; + }; + Cache2.prototype.invalidate = function() { + this.value = void 0; + }; + Cache2.populatedBy = function(populate) { + return new Cache2(populate); + }; + return Cache2; + }() +); +var Cache_default = Cache; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/errors.js +var MethodNotImplementedError = ( + /** @class */ + function(_super) { + __extends(MethodNotImplementedError2, _super); + function MethodNotImplementedError2(className, methodName) { + var _this = this; + var msg = "Method " + className + "." + methodName + "() not implemented"; + _this = _super.call(this, msg) || this; + return _this; + } + return MethodNotImplementedError2; + }(Error) +); +var PrivateConstructorError = ( + /** @class */ + function(_super) { + __extends(PrivateConstructorError2, _super); + function PrivateConstructorError2(className) { + var _this = this; + var msg = "Cannot construct " + className + " - it has a private constructor"; + _this = _super.call(this, msg) || this; + return _this; + } + return PrivateConstructorError2; + }(Error) +); +var UnexpectedObjectTypeError = ( + /** @class */ + function(_super) { + __extends(UnexpectedObjectTypeError2, _super); + function UnexpectedObjectTypeError2(expected, actual) { + var _this = this; + var name = function(t) { + var _a, _b; + return (_a = t === null || t === void 0 ? void 0 : t.name) !== null && _a !== void 0 ? _a : (_b = t === null || t === void 0 ? void 0 : t.constructor) === null || _b === void 0 ? void 0 : _b.name; + }; + var expectedTypes = Array.isArray(expected) ? expected.map(name) : [name(expected)]; + var msg = "Expected instance of " + expectedTypes.join(" or ") + ", " + ("but got instance of " + (actual ? name(actual) : actual)); + _this = _super.call(this, msg) || this; + return _this; + } + return UnexpectedObjectTypeError2; + }(Error) +); +var UnsupportedEncodingError = ( + /** @class */ + function(_super) { + __extends(UnsupportedEncodingError2, _super); + function UnsupportedEncodingError2(encoding) { + var _this = this; + var msg = encoding + " stream encoding not supported"; + _this = _super.call(this, msg) || this; + return _this; + } + return UnsupportedEncodingError2; + }(Error) +); +var ReparseError = ( + /** @class */ + function(_super) { + __extends(ReparseError2, _super); + function ReparseError2(className, methodName) { + var _this = this; + var msg = "Cannot call " + className + "." + methodName + "() more than once"; + _this = _super.call(this, msg) || this; + return _this; + } + return ReparseError2; + }(Error) +); +var MissingCatalogError = ( + /** @class */ + function(_super) { + __extends(MissingCatalogError2, _super); + function MissingCatalogError2(ref) { + var _this = this; + var msg = "Missing catalog (ref=" + ref + ")"; + _this = _super.call(this, msg) || this; + return _this; + } + return MissingCatalogError2; + }(Error) +); +var MissingPageContentsEmbeddingError = ( + /** @class */ + function(_super) { + __extends(MissingPageContentsEmbeddingError2, _super); + function MissingPageContentsEmbeddingError2() { + var _this = this; + var msg = "Can't embed page with missing Contents"; + _this = _super.call(this, msg) || this; + return _this; + } + return MissingPageContentsEmbeddingError2; + }(Error) +); +var UnrecognizedStreamTypeError = ( + /** @class */ + function(_super) { + __extends(UnrecognizedStreamTypeError2, _super); + function UnrecognizedStreamTypeError2(stream2) { + var _a, _b, _c; + var _this = this; + var streamType = (_c = (_b = (_a = stream2 === null || stream2 === void 0 ? void 0 : stream2.contructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : stream2 === null || stream2 === void 0 ? void 0 : stream2.name) !== null && _c !== void 0 ? _c : stream2; + var msg = "Unrecognized stream type: " + streamType; + _this = _super.call(this, msg) || this; + return _this; + } + return UnrecognizedStreamTypeError2; + }(Error) +); +var PageEmbeddingMismatchedContextError = ( + /** @class */ + function(_super) { + __extends(PageEmbeddingMismatchedContextError2, _super); + function PageEmbeddingMismatchedContextError2() { + var _this = this; + var msg = "Found mismatched contexts while embedding pages. All pages in the array passed to `PDFDocument.embedPages()` must be from the same document."; + _this = _super.call(this, msg) || this; + return _this; + } + return PageEmbeddingMismatchedContextError2; + }(Error) +); +var PDFArrayIsNotRectangleError = ( + /** @class */ + function(_super) { + __extends(PDFArrayIsNotRectangleError2, _super); + function PDFArrayIsNotRectangleError2(size) { + var _this = this; + var msg = "Attempted to convert PDFArray with " + size + " elements to rectangle, but must have exactly 4 elements."; + _this = _super.call(this, msg) || this; + return _this; + } + return PDFArrayIsNotRectangleError2; + }(Error) +); +var InvalidPDFDateStringError = ( + /** @class */ + function(_super) { + __extends(InvalidPDFDateStringError2, _super); + function InvalidPDFDateStringError2(value) { + var _this = this; + var msg = 'Attempted to convert "' + value + '" to a date, but it does not match the PDF date string format.'; + _this = _super.call(this, msg) || this; + return _this; + } + return InvalidPDFDateStringError2; + }(Error) +); +var InvalidTargetIndexError = ( + /** @class */ + function(_super) { + __extends(InvalidTargetIndexError2, _super); + function InvalidTargetIndexError2(targetIndex, Count) { + var _this = this; + var msg = "Invalid targetIndex specified: targetIndex=" + targetIndex + " must be less than Count=" + Count; + _this = _super.call(this, msg) || this; + return _this; + } + return InvalidTargetIndexError2; + }(Error) +); +var CorruptPageTreeError = ( + /** @class */ + function(_super) { + __extends(CorruptPageTreeError2, _super); + function CorruptPageTreeError2(targetIndex, operation) { + var _this = this; + var msg = "Failed to " + operation + " at targetIndex=" + targetIndex + " due to corrupt page tree: It is likely that one or more 'Count' entries are invalid"; + _this = _super.call(this, msg) || this; + return _this; + } + return CorruptPageTreeError2; + }(Error) +); +var IndexOutOfBoundsError = ( + /** @class */ + function(_super) { + __extends(IndexOutOfBoundsError2, _super); + function IndexOutOfBoundsError2(index, min, max) { + var _this = this; + var msg = "index should be at least " + min + " and at most " + max + ", but was actually " + index; + _this = _super.call(this, msg) || this; + return _this; + } + return IndexOutOfBoundsError2; + }(Error) +); +var InvalidAcroFieldValueError = ( + /** @class */ + function(_super) { + __extends(InvalidAcroFieldValueError2, _super); + function InvalidAcroFieldValueError2() { + var _this = this; + var msg = "Attempted to set invalid field value"; + _this = _super.call(this, msg) || this; + return _this; + } + return InvalidAcroFieldValueError2; + }(Error) +); +var MultiSelectValueError = ( + /** @class */ + function(_super) { + __extends(MultiSelectValueError2, _super); + function MultiSelectValueError2() { + var _this = this; + var msg = "Attempted to select multiple values for single-select field"; + _this = _super.call(this, msg) || this; + return _this; + } + return MultiSelectValueError2; + }(Error) +); +var MissingDAEntryError = ( + /** @class */ + function(_super) { + __extends(MissingDAEntryError2, _super); + function MissingDAEntryError2(fieldName) { + var _this = this; + var msg = "No /DA (default appearance) entry found for field: " + fieldName; + _this = _super.call(this, msg) || this; + return _this; + } + return MissingDAEntryError2; + }(Error) +); +var MissingTfOperatorError = ( + /** @class */ + function(_super) { + __extends(MissingTfOperatorError2, _super); + function MissingTfOperatorError2(fieldName) { + var _this = this; + var msg = "No Tf operator found for DA of field: " + fieldName; + _this = _super.call(this, msg) || this; + return _this; + } + return MissingTfOperatorError2; + }(Error) +); +var NumberParsingError = ( + /** @class */ + function(_super) { + __extends(NumberParsingError2, _super); + function NumberParsingError2(pos, value) { + var _this = this; + var msg = "Failed to parse number " + ("(line:" + pos.line + " col:" + pos.column + " offset=" + pos.offset + '): "' + value + '"'); + _this = _super.call(this, msg) || this; + return _this; + } + return NumberParsingError2; + }(Error) +); +var PDFParsingError = ( + /** @class */ + function(_super) { + __extends(PDFParsingError2, _super); + function PDFParsingError2(pos, details) { + var _this = this; + var msg = "Failed to parse PDF document " + ("(line:" + pos.line + " col:" + pos.column + " offset=" + pos.offset + "): " + details); + _this = _super.call(this, msg) || this; + return _this; + } + return PDFParsingError2; + }(Error) +); +var NextByteAssertionError = ( + /** @class */ + function(_super) { + __extends(NextByteAssertionError2, _super); + function NextByteAssertionError2(pos, expectedByte, actualByte) { + var _this = this; + var msg = "Expected next byte to be " + expectedByte + " but it was actually " + actualByte; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return NextByteAssertionError2; + }(PDFParsingError) +); +var PDFObjectParsingError = ( + /** @class */ + function(_super) { + __extends(PDFObjectParsingError2, _super); + function PDFObjectParsingError2(pos, byte) { + var _this = this; + var msg = "Failed to parse PDF object starting with the following byte: " + byte; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return PDFObjectParsingError2; + }(PDFParsingError) +); +var PDFInvalidObjectParsingError = ( + /** @class */ + function(_super) { + __extends(PDFInvalidObjectParsingError2, _super); + function PDFInvalidObjectParsingError2(pos) { + var _this = this; + var msg = "Failed to parse invalid PDF object"; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return PDFInvalidObjectParsingError2; + }(PDFParsingError) +); +var PDFStreamParsingError = ( + /** @class */ + function(_super) { + __extends(PDFStreamParsingError2, _super); + function PDFStreamParsingError2(pos) { + var _this = this; + var msg = "Failed to parse PDF stream"; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return PDFStreamParsingError2; + }(PDFParsingError) +); +var UnbalancedParenthesisError = ( + /** @class */ + function(_super) { + __extends(UnbalancedParenthesisError2, _super); + function UnbalancedParenthesisError2(pos) { + var _this = this; + var msg = "Failed to parse PDF literal string due to unbalanced parenthesis"; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return UnbalancedParenthesisError2; + }(PDFParsingError) +); +var StalledParserError = ( + /** @class */ + function(_super) { + __extends(StalledParserError2, _super); + function StalledParserError2(pos) { + var _this = this; + var msg = "Parser stalled"; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return StalledParserError2; + }(PDFParsingError) +); +var MissingPDFHeaderError = ( + /** @class */ + function(_super) { + __extends(MissingPDFHeaderError2, _super); + function MissingPDFHeaderError2(pos) { + var _this = this; + var msg = "No PDF header found"; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return MissingPDFHeaderError2; + }(PDFParsingError) +); +var MissingKeywordError = ( + /** @class */ + function(_super) { + __extends(MissingKeywordError2, _super); + function MissingKeywordError2(pos, keyword) { + var _this = this; + var msg = "Did not find expected keyword '" + arrayAsString(keyword) + "'"; + _this = _super.call(this, pos, msg) || this; + return _this; + } + return MissingKeywordError2; + }(PDFParsingError) +); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/syntax/CharCodes.js +var CharCodes; +(function(CharCodes2) { + CharCodes2[CharCodes2["Null"] = 0] = "Null"; + CharCodes2[CharCodes2["Backspace"] = 8] = "Backspace"; + CharCodes2[CharCodes2["Tab"] = 9] = "Tab"; + CharCodes2[CharCodes2["Newline"] = 10] = "Newline"; + CharCodes2[CharCodes2["FormFeed"] = 12] = "FormFeed"; + CharCodes2[CharCodes2["CarriageReturn"] = 13] = "CarriageReturn"; + CharCodes2[CharCodes2["Space"] = 32] = "Space"; + CharCodes2[CharCodes2["ExclamationPoint"] = 33] = "ExclamationPoint"; + CharCodes2[CharCodes2["Hash"] = 35] = "Hash"; + CharCodes2[CharCodes2["Percent"] = 37] = "Percent"; + CharCodes2[CharCodes2["LeftParen"] = 40] = "LeftParen"; + CharCodes2[CharCodes2["RightParen"] = 41] = "RightParen"; + CharCodes2[CharCodes2["Plus"] = 43] = "Plus"; + CharCodes2[CharCodes2["Minus"] = 45] = "Minus"; + CharCodes2[CharCodes2["Dash"] = 45] = "Dash"; + CharCodes2[CharCodes2["Period"] = 46] = "Period"; + CharCodes2[CharCodes2["ForwardSlash"] = 47] = "ForwardSlash"; + CharCodes2[CharCodes2["Zero"] = 48] = "Zero"; + CharCodes2[CharCodes2["One"] = 49] = "One"; + CharCodes2[CharCodes2["Two"] = 50] = "Two"; + CharCodes2[CharCodes2["Three"] = 51] = "Three"; + CharCodes2[CharCodes2["Four"] = 52] = "Four"; + CharCodes2[CharCodes2["Five"] = 53] = "Five"; + CharCodes2[CharCodes2["Six"] = 54] = "Six"; + CharCodes2[CharCodes2["Seven"] = 55] = "Seven"; + CharCodes2[CharCodes2["Eight"] = 56] = "Eight"; + CharCodes2[CharCodes2["Nine"] = 57] = "Nine"; + CharCodes2[CharCodes2["LessThan"] = 60] = "LessThan"; + CharCodes2[CharCodes2["GreaterThan"] = 62] = "GreaterThan"; + CharCodes2[CharCodes2["A"] = 65] = "A"; + CharCodes2[CharCodes2["D"] = 68] = "D"; + CharCodes2[CharCodes2["E"] = 69] = "E"; + CharCodes2[CharCodes2["F"] = 70] = "F"; + CharCodes2[CharCodes2["O"] = 79] = "O"; + CharCodes2[CharCodes2["P"] = 80] = "P"; + CharCodes2[CharCodes2["R"] = 82] = "R"; + CharCodes2[CharCodes2["LeftSquareBracket"] = 91] = "LeftSquareBracket"; + CharCodes2[CharCodes2["BackSlash"] = 92] = "BackSlash"; + CharCodes2[CharCodes2["RightSquareBracket"] = 93] = "RightSquareBracket"; + CharCodes2[CharCodes2["a"] = 97] = "a"; + CharCodes2[CharCodes2["b"] = 98] = "b"; + CharCodes2[CharCodes2["d"] = 100] = "d"; + CharCodes2[CharCodes2["e"] = 101] = "e"; + CharCodes2[CharCodes2["f"] = 102] = "f"; + CharCodes2[CharCodes2["i"] = 105] = "i"; + CharCodes2[CharCodes2["j"] = 106] = "j"; + CharCodes2[CharCodes2["l"] = 108] = "l"; + CharCodes2[CharCodes2["m"] = 109] = "m"; + CharCodes2[CharCodes2["n"] = 110] = "n"; + CharCodes2[CharCodes2["o"] = 111] = "o"; + CharCodes2[CharCodes2["r"] = 114] = "r"; + CharCodes2[CharCodes2["s"] = 115] = "s"; + CharCodes2[CharCodes2["t"] = 116] = "t"; + CharCodes2[CharCodes2["u"] = 117] = "u"; + CharCodes2[CharCodes2["x"] = 120] = "x"; + CharCodes2[CharCodes2["LeftCurly"] = 123] = "LeftCurly"; + CharCodes2[CharCodes2["RightCurly"] = 125] = "RightCurly"; + CharCodes2[CharCodes2["Tilde"] = 126] = "Tilde"; +})(CharCodes || (CharCodes = {})); +var CharCodes_default = CharCodes; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/PDFContext.js +var import_pako3 = __toESM(require_pako()); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/document/PDFHeader.js +var PDFHeader = ( + /** @class */ + function() { + function PDFHeader2(major, minor) { + this.major = String(major); + this.minor = String(minor); + } + PDFHeader2.prototype.toString = function() { + var bc = charFromCode(129); + return "%PDF-" + this.major + "." + this.minor + "\n%" + bc + bc + bc + bc; + }; + PDFHeader2.prototype.sizeInBytes = function() { + return 12 + this.major.length + this.minor.length; + }; + PDFHeader2.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + buffer[offset++] = CharCodes_default.Percent; + buffer[offset++] = CharCodes_default.P; + buffer[offset++] = CharCodes_default.D; + buffer[offset++] = CharCodes_default.F; + buffer[offset++] = CharCodes_default.Dash; + offset += copyStringIntoBuffer(this.major, buffer, offset); + buffer[offset++] = CharCodes_default.Period; + offset += copyStringIntoBuffer(this.minor, buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.Percent; + buffer[offset++] = 129; + buffer[offset++] = 129; + buffer[offset++] = 129; + buffer[offset++] = 129; + return offset - initialOffset; + }; + PDFHeader2.forVersion = function(major, minor) { + return new PDFHeader2(major, minor); + }; + return PDFHeader2; + }() +); +var PDFHeader_default = PDFHeader; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFObject.js +var PDFObject = ( + /** @class */ + function() { + function PDFObject2() { + } + PDFObject2.prototype.clone = function(_context) { + throw new MethodNotImplementedError(this.constructor.name, "clone"); + }; + PDFObject2.prototype.toString = function() { + throw new MethodNotImplementedError(this.constructor.name, "toString"); + }; + PDFObject2.prototype.sizeInBytes = function() { + throw new MethodNotImplementedError(this.constructor.name, "sizeInBytes"); + }; + PDFObject2.prototype.copyBytesInto = function(_buffer, _offset) { + throw new MethodNotImplementedError(this.constructor.name, "copyBytesInto"); + }; + return PDFObject2; + }() +); +var PDFObject_default = PDFObject; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFNumber.js +var PDFNumber = ( + /** @class */ + function(_super) { + __extends(PDFNumber2, _super); + function PDFNumber2(value) { + var _this = _super.call(this) || this; + _this.numberValue = value; + _this.stringValue = numberToString(value); + return _this; + } + PDFNumber2.prototype.asNumber = function() { + return this.numberValue; + }; + PDFNumber2.prototype.value = function() { + return this.numberValue; + }; + PDFNumber2.prototype.clone = function() { + return PDFNumber2.of(this.numberValue); + }; + PDFNumber2.prototype.toString = function() { + return this.stringValue; + }; + PDFNumber2.prototype.sizeInBytes = function() { + return this.stringValue.length; + }; + PDFNumber2.prototype.copyBytesInto = function(buffer, offset) { + offset += copyStringIntoBuffer(this.stringValue, buffer, offset); + return this.stringValue.length; + }; + PDFNumber2.of = function(value) { + return new PDFNumber2(value); + }; + return PDFNumber2; + }(PDFObject_default) +); +var PDFNumber_default = PDFNumber; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFArray.js +var PDFArray = ( + /** @class */ + function(_super) { + __extends(PDFArray3, _super); + function PDFArray3(context) { + var _this = _super.call(this) || this; + _this.array = []; + _this.context = context; + return _this; + } + PDFArray3.prototype.size = function() { + return this.array.length; + }; + PDFArray3.prototype.push = function(object) { + this.array.push(object); + }; + PDFArray3.prototype.insert = function(index, object) { + this.array.splice(index, 0, object); + }; + PDFArray3.prototype.indexOf = function(object) { + var index = this.array.indexOf(object); + return index === -1 ? void 0 : index; + }; + PDFArray3.prototype.remove = function(index) { + this.array.splice(index, 1); + }; + PDFArray3.prototype.set = function(idx, object) { + this.array[idx] = object; + }; + PDFArray3.prototype.get = function(index) { + return this.array[index]; + }; + PDFArray3.prototype.lookupMaybe = function(index) { + var _a; + var types = []; + for (var _i = 1; _i < arguments.length; _i++) { + types[_i - 1] = arguments[_i]; + } + return (_a = this.context).lookupMaybe.apply(_a, __spreadArrays([this.get(index)], types)); + }; + PDFArray3.prototype.lookup = function(index) { + var _a; + var types = []; + for (var _i = 1; _i < arguments.length; _i++) { + types[_i - 1] = arguments[_i]; + } + return (_a = this.context).lookup.apply(_a, __spreadArrays([this.get(index)], types)); + }; + PDFArray3.prototype.asRectangle = function() { + if (this.size() !== 4) + throw new PDFArrayIsNotRectangleError(this.size()); + var lowerLeftX = this.lookup(0, PDFNumber_default).asNumber(); + var lowerLeftY = this.lookup(1, PDFNumber_default).asNumber(); + var upperRightX = this.lookup(2, PDFNumber_default).asNumber(); + var upperRightY = this.lookup(3, PDFNumber_default).asNumber(); + var x = lowerLeftX; + var y = lowerLeftY; + var width = upperRightX - lowerLeftX; + var height = upperRightY - lowerLeftY; + return { x, y, width, height }; + }; + PDFArray3.prototype.asArray = function() { + return this.array.slice(); + }; + PDFArray3.prototype.clone = function(context) { + var clone = PDFArray3.withContext(context || this.context); + for (var idx = 0, len = this.size(); idx < len; idx++) { + clone.push(this.array[idx]); + } + return clone; + }; + PDFArray3.prototype.toString = function() { + var arrayString = "[ "; + for (var idx = 0, len = this.size(); idx < len; idx++) { + arrayString += this.get(idx).toString(); + arrayString += " "; + } + arrayString += "]"; + return arrayString; + }; + PDFArray3.prototype.sizeInBytes = function() { + var size = 3; + for (var idx = 0, len = this.size(); idx < len; idx++) { + size += this.get(idx).sizeInBytes() + 1; + } + return size; + }; + PDFArray3.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + buffer[offset++] = CharCodes_default.LeftSquareBracket; + buffer[offset++] = CharCodes_default.Space; + for (var idx = 0, len = this.size(); idx < len; idx++) { + offset += this.get(idx).copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Space; + } + buffer[offset++] = CharCodes_default.RightSquareBracket; + return offset - initialOffset; + }; + PDFArray3.prototype.scalePDFNumbers = function(x, y) { + for (var idx = 0, len = this.size(); idx < len; idx++) { + var el = this.lookup(idx); + if (el instanceof PDFNumber_default) { + var factor = idx % 2 === 0 ? x : y; + this.set(idx, PDFNumber_default.of(el.asNumber() * factor)); + } + } + }; + PDFArray3.withContext = function(context) { + return new PDFArray3(context); + }; + return PDFArray3; + }(PDFObject_default) +); +var PDFArray_default = PDFArray; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFBool.js +var ENFORCER = {}; +var PDFBool = ( + /** @class */ + function(_super) { + __extends(PDFBool2, _super); + function PDFBool2(enforcer, value) { + var _this = this; + if (enforcer !== ENFORCER) + throw new PrivateConstructorError("PDFBool"); + _this = _super.call(this) || this; + _this.value = value; + return _this; + } + PDFBool2.prototype.asBoolean = function() { + return this.value; + }; + PDFBool2.prototype.clone = function() { + return this; + }; + PDFBool2.prototype.toString = function() { + return String(this.value); + }; + PDFBool2.prototype.sizeInBytes = function() { + return this.value ? 4 : 5; + }; + PDFBool2.prototype.copyBytesInto = function(buffer, offset) { + if (this.value) { + buffer[offset++] = CharCodes_default.t; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.u; + buffer[offset++] = CharCodes_default.e; + return 4; + } else { + buffer[offset++] = CharCodes_default.f; + buffer[offset++] = CharCodes_default.a; + buffer[offset++] = CharCodes_default.l; + buffer[offset++] = CharCodes_default.s; + buffer[offset++] = CharCodes_default.e; + return 5; + } + }; + PDFBool2.True = new PDFBool2(ENFORCER, true); + PDFBool2.False = new PDFBool2(ENFORCER, false); + return PDFBool2; + }(PDFObject_default) +); +var PDFBool_default = PDFBool; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/syntax/Delimiters.js +var IsDelimiter = new Uint8Array(256); +IsDelimiter[CharCodes_default.LeftParen] = 1; +IsDelimiter[CharCodes_default.RightParen] = 1; +IsDelimiter[CharCodes_default.LessThan] = 1; +IsDelimiter[CharCodes_default.GreaterThan] = 1; +IsDelimiter[CharCodes_default.LeftSquareBracket] = 1; +IsDelimiter[CharCodes_default.RightSquareBracket] = 1; +IsDelimiter[CharCodes_default.LeftCurly] = 1; +IsDelimiter[CharCodes_default.RightCurly] = 1; +IsDelimiter[CharCodes_default.ForwardSlash] = 1; +IsDelimiter[CharCodes_default.Percent] = 1; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/syntax/Whitespace.js +var IsWhitespace = new Uint8Array(256); +IsWhitespace[CharCodes_default.Null] = 1; +IsWhitespace[CharCodes_default.Tab] = 1; +IsWhitespace[CharCodes_default.Newline] = 1; +IsWhitespace[CharCodes_default.FormFeed] = 1; +IsWhitespace[CharCodes_default.CarriageReturn] = 1; +IsWhitespace[CharCodes_default.Space] = 1; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/syntax/Irregular.js +var IsIrregular = new Uint8Array(256); +for (idx = 0, len = 256; idx < len; idx++) { + IsIrregular[idx] = IsWhitespace[idx] || IsDelimiter[idx] ? 1 : 0; +} +var idx; +var len; +IsIrregular[CharCodes_default.Hash] = 1; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFName.js +var decodeName = function(name) { + return name.replace(/#([\dABCDEF]{2})/g, function(_, hex) { + return charFromHexCode(hex); + }); +}; +var isRegularChar = function(charCode) { + return charCode >= CharCodes_default.ExclamationPoint && charCode <= CharCodes_default.Tilde && !IsIrregular[charCode]; +}; +var ENFORCER2 = {}; +var pool = /* @__PURE__ */ new Map(); +var PDFName = ( + /** @class */ + function(_super) { + __extends(PDFName2, _super); + function PDFName2(enforcer, name) { + var _this = this; + if (enforcer !== ENFORCER2) + throw new PrivateConstructorError("PDFName"); + _this = _super.call(this) || this; + var encodedName = "/"; + for (var idx = 0, len = name.length; idx < len; idx++) { + var character = name[idx]; + var code = toCharCode(character); + encodedName += isRegularChar(code) ? character : "#" + toHexString(code); + } + _this.encodedName = encodedName; + return _this; + } + PDFName2.prototype.asBytes = function() { + var bytes = []; + var hex = ""; + var escaped = false; + var pushByte = function(byte2) { + if (byte2 !== void 0) + bytes.push(byte2); + escaped = false; + }; + for (var idx = 1, len = this.encodedName.length; idx < len; idx++) { + var char = this.encodedName[idx]; + var byte = toCharCode(char); + var nextChar = this.encodedName[idx + 1]; + if (!escaped) { + if (byte === CharCodes_default.Hash) + escaped = true; + else + pushByte(byte); + } else { + if (byte >= CharCodes_default.Zero && byte <= CharCodes_default.Nine || byte >= CharCodes_default.a && byte <= CharCodes_default.f || byte >= CharCodes_default.A && byte <= CharCodes_default.F) { + hex += char; + if (hex.length === 2 || !(nextChar >= "0" && nextChar <= "9" || nextChar >= "a" && nextChar <= "f" || nextChar >= "A" && nextChar <= "F")) { + pushByte(parseInt(hex, 16)); + hex = ""; + } + } else { + pushByte(byte); + } + } + } + return new Uint8Array(bytes); + }; + PDFName2.prototype.decodeText = function() { + var bytes = this.asBytes(); + return String.fromCharCode.apply(String, Array.from(bytes)); + }; + PDFName2.prototype.asString = function() { + return this.encodedName; + }; + PDFName2.prototype.value = function() { + return this.encodedName; + }; + PDFName2.prototype.clone = function() { + return this; + }; + PDFName2.prototype.toString = function() { + return this.encodedName; + }; + PDFName2.prototype.sizeInBytes = function() { + return this.encodedName.length; + }; + PDFName2.prototype.copyBytesInto = function(buffer, offset) { + offset += copyStringIntoBuffer(this.encodedName, buffer, offset); + return this.encodedName.length; + }; + PDFName2.of = function(name) { + var decodedValue = decodeName(name); + var instance = pool.get(decodedValue); + if (!instance) { + instance = new PDFName2(ENFORCER2, decodedValue); + pool.set(decodedValue, instance); + } + return instance; + }; + PDFName2.Length = PDFName2.of("Length"); + PDFName2.FlateDecode = PDFName2.of("FlateDecode"); + PDFName2.Resources = PDFName2.of("Resources"); + PDFName2.Font = PDFName2.of("Font"); + PDFName2.XObject = PDFName2.of("XObject"); + PDFName2.ExtGState = PDFName2.of("ExtGState"); + PDFName2.Contents = PDFName2.of("Contents"); + PDFName2.Type = PDFName2.of("Type"); + PDFName2.Parent = PDFName2.of("Parent"); + PDFName2.MediaBox = PDFName2.of("MediaBox"); + PDFName2.Page = PDFName2.of("Page"); + PDFName2.Annots = PDFName2.of("Annots"); + PDFName2.TrimBox = PDFName2.of("TrimBox"); + PDFName2.ArtBox = PDFName2.of("ArtBox"); + PDFName2.BleedBox = PDFName2.of("BleedBox"); + PDFName2.CropBox = PDFName2.of("CropBox"); + PDFName2.Rotate = PDFName2.of("Rotate"); + PDFName2.Title = PDFName2.of("Title"); + PDFName2.Author = PDFName2.of("Author"); + PDFName2.Subject = PDFName2.of("Subject"); + PDFName2.Creator = PDFName2.of("Creator"); + PDFName2.Keywords = PDFName2.of("Keywords"); + PDFName2.Producer = PDFName2.of("Producer"); + PDFName2.CreationDate = PDFName2.of("CreationDate"); + PDFName2.ModDate = PDFName2.of("ModDate"); + return PDFName2; + }(PDFObject_default) +); +var PDFName_default = PDFName; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFNull.js +var PDFNull = ( + /** @class */ + function(_super) { + __extends(PDFNull2, _super); + function PDFNull2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFNull2.prototype.asNull = function() { + return null; + }; + PDFNull2.prototype.clone = function() { + return this; + }; + PDFNull2.prototype.toString = function() { + return "null"; + }; + PDFNull2.prototype.sizeInBytes = function() { + return 4; + }; + PDFNull2.prototype.copyBytesInto = function(buffer, offset) { + buffer[offset++] = CharCodes_default.n; + buffer[offset++] = CharCodes_default.u; + buffer[offset++] = CharCodes_default.l; + buffer[offset++] = CharCodes_default.l; + return 4; + }; + return PDFNull2; + }(PDFObject_default) +); +var PDFNull_default = new PDFNull(); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFDict.js +var PDFDict = ( + /** @class */ + function(_super) { + __extends(PDFDict2, _super); + function PDFDict2(map, context) { + var _this = _super.call(this) || this; + _this.dict = map; + _this.context = context; + return _this; + } + PDFDict2.prototype.keys = function() { + return Array.from(this.dict.keys()); + }; + PDFDict2.prototype.values = function() { + return Array.from(this.dict.values()); + }; + PDFDict2.prototype.entries = function() { + return Array.from(this.dict.entries()); + }; + PDFDict2.prototype.set = function(key, value) { + this.dict.set(key, value); + }; + PDFDict2.prototype.get = function(key, preservePDFNull) { + if (preservePDFNull === void 0) { + preservePDFNull = false; + } + var value = this.dict.get(key); + if (value === PDFNull_default && !preservePDFNull) + return void 0; + return value; + }; + PDFDict2.prototype.has = function(key) { + var value = this.dict.get(key); + return value !== void 0 && value !== PDFNull_default; + }; + PDFDict2.prototype.lookupMaybe = function(key) { + var _a; + var types = []; + for (var _i = 1; _i < arguments.length; _i++) { + types[_i - 1] = arguments[_i]; + } + var preservePDFNull = types.includes(PDFNull_default); + var value = (_a = this.context).lookupMaybe.apply(_a, __spreadArrays([this.get(key, preservePDFNull)], types)); + if (value === PDFNull_default && !preservePDFNull) + return void 0; + return value; + }; + PDFDict2.prototype.lookup = function(key) { + var _a; + var types = []; + for (var _i = 1; _i < arguments.length; _i++) { + types[_i - 1] = arguments[_i]; + } + var preservePDFNull = types.includes(PDFNull_default); + var value = (_a = this.context).lookup.apply(_a, __spreadArrays([this.get(key, preservePDFNull)], types)); + if (value === PDFNull_default && !preservePDFNull) + return void 0; + return value; + }; + PDFDict2.prototype.delete = function(key) { + return this.dict.delete(key); + }; + PDFDict2.prototype.asMap = function() { + return new Map(this.dict); + }; + PDFDict2.prototype.uniqueKey = function(tag) { + if (tag === void 0) { + tag = ""; + } + var existingKeys = this.keys(); + var key = PDFName_default.of(this.context.addRandomSuffix(tag, 10)); + while (existingKeys.includes(key)) { + key = PDFName_default.of(this.context.addRandomSuffix(tag, 10)); + } + return key; + }; + PDFDict2.prototype.clone = function(context) { + var clone = PDFDict2.withContext(context || this.context); + var entries = this.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + clone.set(key, value); + } + return clone; + }; + PDFDict2.prototype.toString = function() { + var dictString = "<<\n"; + var entries = this.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + dictString += key.toString() + " " + value.toString() + "\n"; + } + dictString += ">>"; + return dictString; + }; + PDFDict2.prototype.sizeInBytes = function() { + var size = 5; + var entries = this.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + size += key.sizeInBytes() + value.sizeInBytes() + 2; + } + return size; + }; + PDFDict2.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + buffer[offset++] = CharCodes_default.LessThan; + buffer[offset++] = CharCodes_default.LessThan; + buffer[offset++] = CharCodes_default.Newline; + var entries = this.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + offset += key.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Space; + offset += value.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + } + buffer[offset++] = CharCodes_default.GreaterThan; + buffer[offset++] = CharCodes_default.GreaterThan; + return offset - initialOffset; + }; + PDFDict2.withContext = function(context) { + return new PDFDict2(/* @__PURE__ */ new Map(), context); + }; + PDFDict2.fromMapWithContext = function(map, context) { + return new PDFDict2(map, context); + }; + return PDFDict2; + }(PDFObject_default) +); +var PDFDict_default = PDFDict; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFStream.js +var PDFStream = ( + /** @class */ + function(_super) { + __extends(PDFStream2, _super); + function PDFStream2(dict) { + var _this = _super.call(this) || this; + _this.dict = dict; + return _this; + } + PDFStream2.prototype.clone = function(_context) { + throw new MethodNotImplementedError(this.constructor.name, "clone"); + }; + PDFStream2.prototype.getContentsString = function() { + throw new MethodNotImplementedError(this.constructor.name, "getContentsString"); + }; + PDFStream2.prototype.getContents = function() { + throw new MethodNotImplementedError(this.constructor.name, "getContents"); + }; + PDFStream2.prototype.getContentsSize = function() { + throw new MethodNotImplementedError(this.constructor.name, "getContentsSize"); + }; + PDFStream2.prototype.updateDict = function() { + var contentsSize = this.getContentsSize(); + this.dict.set(PDFName_default.Length, PDFNumber_default.of(contentsSize)); + }; + PDFStream2.prototype.sizeInBytes = function() { + this.updateDict(); + return this.dict.sizeInBytes() + this.getContentsSize() + 18; + }; + PDFStream2.prototype.toString = function() { + this.updateDict(); + var streamString = this.dict.toString(); + streamString += "\nstream\n"; + streamString += this.getContentsString(); + streamString += "\nendstream"; + return streamString; + }; + PDFStream2.prototype.copyBytesInto = function(buffer, offset) { + this.updateDict(); + var initialOffset = offset; + offset += this.dict.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.s; + buffer[offset++] = CharCodes_default.t; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.a; + buffer[offset++] = CharCodes_default.m; + buffer[offset++] = CharCodes_default.Newline; + var contents = this.getContents(); + for (var idx = 0, len = contents.length; idx < len; idx++) { + buffer[offset++] = contents[idx]; + } + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.n; + buffer[offset++] = CharCodes_default.d; + buffer[offset++] = CharCodes_default.s; + buffer[offset++] = CharCodes_default.t; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.a; + buffer[offset++] = CharCodes_default.m; + return offset - initialOffset; + }; + return PDFStream2; + }(PDFObject_default) +); +var PDFStream_default = PDFStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFRawStream.js +var PDFRawStream = ( + /** @class */ + function(_super) { + __extends(PDFRawStream2, _super); + function PDFRawStream2(dict, contents) { + var _this = _super.call(this, dict) || this; + _this.contents = contents; + return _this; + } + PDFRawStream2.prototype.asUint8Array = function() { + return this.contents.slice(); + }; + PDFRawStream2.prototype.clone = function(context) { + return PDFRawStream2.of(this.dict.clone(context), this.contents.slice()); + }; + PDFRawStream2.prototype.getContentsString = function() { + return arrayAsString(this.contents); + }; + PDFRawStream2.prototype.getContents = function() { + return this.contents; + }; + PDFRawStream2.prototype.getContentsSize = function() { + return this.contents.length; + }; + PDFRawStream2.of = function(dict, contents) { + return new PDFRawStream2(dict, contents); + }; + return PDFRawStream2; + }(PDFStream_default) +); +var PDFRawStream_default = PDFRawStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFRef.js +var ENFORCER3 = {}; +var pool2 = /* @__PURE__ */ new Map(); +var PDFRef = ( + /** @class */ + function(_super) { + __extends(PDFRef3, _super); + function PDFRef3(enforcer, objectNumber, generationNumber) { + var _this = this; + if (enforcer !== ENFORCER3) + throw new PrivateConstructorError("PDFRef"); + _this = _super.call(this) || this; + _this.objectNumber = objectNumber; + _this.generationNumber = generationNumber; + _this.tag = objectNumber + " " + generationNumber + " R"; + return _this; + } + PDFRef3.prototype.clone = function() { + return this; + }; + PDFRef3.prototype.toString = function() { + return this.tag; + }; + PDFRef3.prototype.sizeInBytes = function() { + return this.tag.length; + }; + PDFRef3.prototype.copyBytesInto = function(buffer, offset) { + offset += copyStringIntoBuffer(this.tag, buffer, offset); + return this.tag.length; + }; + PDFRef3.of = function(objectNumber, generationNumber) { + if (generationNumber === void 0) { + generationNumber = 0; + } + var tag = objectNumber + " " + generationNumber + " R"; + var instance = pool2.get(tag); + if (!instance) { + instance = new PDFRef3(ENFORCER3, objectNumber, generationNumber); + pool2.set(tag, instance); + } + return instance; + }; + return PDFRef3; + }(PDFObject_default) +); +var PDFRef_default = PDFRef; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/operators/PDFOperator.js +var PDFOperator = ( + /** @class */ + function() { + function PDFOperator2(name, args) { + this.name = name; + this.args = args || []; + } + PDFOperator2.prototype.clone = function(context) { + var args = new Array(this.args.length); + for (var idx = 0, len = args.length; idx < len; idx++) { + var arg = this.args[idx]; + args[idx] = arg instanceof PDFObject_default ? arg.clone(context) : arg; + } + return PDFOperator2.of(this.name, args); + }; + PDFOperator2.prototype.toString = function() { + var value = ""; + for (var idx = 0, len = this.args.length; idx < len; idx++) { + value += String(this.args[idx]) + " "; + } + value += this.name; + return value; + }; + PDFOperator2.prototype.sizeInBytes = function() { + var size = 0; + for (var idx = 0, len = this.args.length; idx < len; idx++) { + var arg = this.args[idx]; + size += (arg instanceof PDFObject_default ? arg.sizeInBytes() : arg.length) + 1; + } + size += this.name.length; + return size; + }; + PDFOperator2.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + for (var idx = 0, len = this.args.length; idx < len; idx++) { + var arg = this.args[idx]; + if (arg instanceof PDFObject_default) { + offset += arg.copyBytesInto(buffer, offset); + } else { + offset += copyStringIntoBuffer(arg, buffer, offset); + } + buffer[offset++] = CharCodes_default.Space; + } + offset += copyStringIntoBuffer(this.name, buffer, offset); + return offset - initialOffset; + }; + PDFOperator2.of = function(name, args) { + return new PDFOperator2(name, args); + }; + return PDFOperator2; + }() +); +var PDFOperator_default = PDFOperator; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/operators/PDFOperatorNames.js +var PDFOperatorNames; +(function(PDFOperatorNames2) { + PDFOperatorNames2["NonStrokingColor"] = "sc"; + PDFOperatorNames2["NonStrokingColorN"] = "scn"; + PDFOperatorNames2["NonStrokingColorRgb"] = "rg"; + PDFOperatorNames2["NonStrokingColorGray"] = "g"; + PDFOperatorNames2["NonStrokingColorCmyk"] = "k"; + PDFOperatorNames2["NonStrokingColorspace"] = "cs"; + PDFOperatorNames2["StrokingColor"] = "SC"; + PDFOperatorNames2["StrokingColorN"] = "SCN"; + PDFOperatorNames2["StrokingColorRgb"] = "RG"; + PDFOperatorNames2["StrokingColorGray"] = "G"; + PDFOperatorNames2["StrokingColorCmyk"] = "K"; + PDFOperatorNames2["StrokingColorspace"] = "CS"; + PDFOperatorNames2["BeginMarkedContentSequence"] = "BDC"; + PDFOperatorNames2["BeginMarkedContent"] = "BMC"; + PDFOperatorNames2["EndMarkedContent"] = "EMC"; + PDFOperatorNames2["MarkedContentPointWithProps"] = "DP"; + PDFOperatorNames2["MarkedContentPoint"] = "MP"; + PDFOperatorNames2["DrawObject"] = "Do"; + PDFOperatorNames2["ConcatTransformationMatrix"] = "cm"; + PDFOperatorNames2["PopGraphicsState"] = "Q"; + PDFOperatorNames2["PushGraphicsState"] = "q"; + PDFOperatorNames2["SetFlatness"] = "i"; + PDFOperatorNames2["SetGraphicsStateParams"] = "gs"; + PDFOperatorNames2["SetLineCapStyle"] = "J"; + PDFOperatorNames2["SetLineDashPattern"] = "d"; + PDFOperatorNames2["SetLineJoinStyle"] = "j"; + PDFOperatorNames2["SetLineMiterLimit"] = "M"; + PDFOperatorNames2["SetLineWidth"] = "w"; + PDFOperatorNames2["SetTextMatrix"] = "Tm"; + PDFOperatorNames2["SetRenderingIntent"] = "ri"; + PDFOperatorNames2["AppendRectangle"] = "re"; + PDFOperatorNames2["BeginInlineImage"] = "BI"; + PDFOperatorNames2["BeginInlineImageData"] = "ID"; + PDFOperatorNames2["EndInlineImage"] = "EI"; + PDFOperatorNames2["ClipEvenOdd"] = "W*"; + PDFOperatorNames2["ClipNonZero"] = "W"; + PDFOperatorNames2["CloseAndStroke"] = "s"; + PDFOperatorNames2["CloseFillEvenOddAndStroke"] = "b*"; + PDFOperatorNames2["CloseFillNonZeroAndStroke"] = "b"; + PDFOperatorNames2["ClosePath"] = "h"; + PDFOperatorNames2["AppendBezierCurve"] = "c"; + PDFOperatorNames2["CurveToReplicateFinalPoint"] = "y"; + PDFOperatorNames2["CurveToReplicateInitialPoint"] = "v"; + PDFOperatorNames2["EndPath"] = "n"; + PDFOperatorNames2["FillEvenOddAndStroke"] = "B*"; + PDFOperatorNames2["FillEvenOdd"] = "f*"; + PDFOperatorNames2["FillNonZeroAndStroke"] = "B"; + PDFOperatorNames2["FillNonZero"] = "f"; + PDFOperatorNames2["LegacyFillNonZero"] = "F"; + PDFOperatorNames2["LineTo"] = "l"; + PDFOperatorNames2["MoveTo"] = "m"; + PDFOperatorNames2["ShadingFill"] = "sh"; + PDFOperatorNames2["StrokePath"] = "S"; + PDFOperatorNames2["BeginText"] = "BT"; + PDFOperatorNames2["EndText"] = "ET"; + PDFOperatorNames2["MoveText"] = "Td"; + PDFOperatorNames2["MoveTextSetLeading"] = "TD"; + PDFOperatorNames2["NextLine"] = "T*"; + PDFOperatorNames2["SetCharacterSpacing"] = "Tc"; + PDFOperatorNames2["SetFontAndSize"] = "Tf"; + PDFOperatorNames2["SetTextHorizontalScaling"] = "Tz"; + PDFOperatorNames2["SetTextLineHeight"] = "TL"; + PDFOperatorNames2["SetTextRenderingMode"] = "Tr"; + PDFOperatorNames2["SetTextRise"] = "Ts"; + PDFOperatorNames2["SetWordSpacing"] = "Tw"; + PDFOperatorNames2["ShowText"] = "Tj"; + PDFOperatorNames2["ShowTextAdjusted"] = "TJ"; + PDFOperatorNames2["ShowTextLine"] = "'"; + PDFOperatorNames2["ShowTextLineAndSpace"] = '"'; + PDFOperatorNames2["Type3D0"] = "d0"; + PDFOperatorNames2["Type3D1"] = "d1"; + PDFOperatorNames2["BeginCompatibilitySection"] = "BX"; + PDFOperatorNames2["EndCompatibilitySection"] = "EX"; +})(PDFOperatorNames || (PDFOperatorNames = {})); +var PDFOperatorNames_default = PDFOperatorNames; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFFlateStream.js +var import_pako2 = __toESM(require_pako()); +var PDFFlateStream = ( + /** @class */ + function(_super) { + __extends(PDFFlateStream2, _super); + function PDFFlateStream2(dict, encode) { + var _this = _super.call(this, dict) || this; + _this.computeContents = function() { + var unencodedContents = _this.getUnencodedContents(); + return _this.encode ? import_pako2.default.deflate(unencodedContents) : unencodedContents; + }; + _this.encode = encode; + if (encode) + dict.set(PDFName_default.of("Filter"), PDFName_default.of("FlateDecode")); + _this.contentsCache = Cache_default.populatedBy(_this.computeContents); + return _this; + } + PDFFlateStream2.prototype.getContents = function() { + return this.contentsCache.access(); + }; + PDFFlateStream2.prototype.getContentsSize = function() { + return this.contentsCache.access().length; + }; + PDFFlateStream2.prototype.getUnencodedContents = function() { + throw new MethodNotImplementedError(this.constructor.name, "getUnencodedContents"); + }; + return PDFFlateStream2; + }(PDFStream_default) +); +var PDFFlateStream_default = PDFFlateStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFContentStream.js +var PDFContentStream = ( + /** @class */ + function(_super) { + __extends(PDFContentStream2, _super); + function PDFContentStream2(dict, operators, encode) { + if (encode === void 0) { + encode = true; + } + var _this = _super.call(this, dict, encode) || this; + _this.operators = operators; + return _this; + } + PDFContentStream2.prototype.push = function() { + var _a; + var operators = []; + for (var _i = 0; _i < arguments.length; _i++) { + operators[_i] = arguments[_i]; + } + (_a = this.operators).push.apply(_a, operators); + }; + PDFContentStream2.prototype.clone = function(context) { + var operators = new Array(this.operators.length); + for (var idx = 0, len = this.operators.length; idx < len; idx++) { + operators[idx] = this.operators[idx].clone(context); + } + var _a = this, dict = _a.dict, encode = _a.encode; + return PDFContentStream2.of(dict.clone(context), operators, encode); + }; + PDFContentStream2.prototype.getContentsString = function() { + var value = ""; + for (var idx = 0, len = this.operators.length; idx < len; idx++) { + value += this.operators[idx] + "\n"; + } + return value; + }; + PDFContentStream2.prototype.getUnencodedContents = function() { + var buffer = new Uint8Array(this.getUnencodedContentsSize()); + var offset = 0; + for (var idx = 0, len = this.operators.length; idx < len; idx++) { + offset += this.operators[idx].copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + } + return buffer; + }; + PDFContentStream2.prototype.getUnencodedContentsSize = function() { + var size = 0; + for (var idx = 0, len = this.operators.length; idx < len; idx++) { + size += this.operators[idx].sizeInBytes() + 1; + } + return size; + }; + PDFContentStream2.of = function(dict, operators, encode) { + if (encode === void 0) { + encode = true; + } + return new PDFContentStream2(dict, operators, encode); + }; + return PDFContentStream2; + }(PDFFlateStream_default) +); +var PDFContentStream_default = PDFContentStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/rng.js +var SimpleRNG = ( + /** @class */ + function() { + function SimpleRNG2(seed) { + this.seed = seed; + } + SimpleRNG2.prototype.nextInt = function() { + var x = Math.sin(this.seed++) * 1e4; + return x - Math.floor(x); + }; + SimpleRNG2.withSeed = function(seed) { + return new SimpleRNG2(seed); + }; + return SimpleRNG2; + }() +); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/PDFContext.js +var byAscendingObjectNumber = function(_a, _b) { + var a = _a[0]; + var b = _b[0]; + return a.objectNumber - b.objectNumber; +}; +var PDFContext = ( + /** @class */ + function() { + function PDFContext2() { + this.largestObjectNumber = 0; + this.header = PDFHeader_default.forVersion(1, 7); + this.trailerInfo = {}; + this.indirectObjects = /* @__PURE__ */ new Map(); + this.rng = SimpleRNG.withSeed(1); + } + PDFContext2.prototype.assign = function(ref, object) { + this.indirectObjects.set(ref, object); + if (ref.objectNumber > this.largestObjectNumber) { + this.largestObjectNumber = ref.objectNumber; + } + }; + PDFContext2.prototype.nextRef = function() { + this.largestObjectNumber += 1; + return PDFRef_default.of(this.largestObjectNumber); + }; + PDFContext2.prototype.register = function(object) { + var ref = this.nextRef(); + this.assign(ref, object); + return ref; + }; + PDFContext2.prototype.delete = function(ref) { + return this.indirectObjects.delete(ref); + }; + PDFContext2.prototype.lookupMaybe = function(ref) { + var types = []; + for (var _i = 1; _i < arguments.length; _i++) { + types[_i - 1] = arguments[_i]; + } + var preservePDFNull = types.includes(PDFNull_default); + var result = ref instanceof PDFRef_default ? this.indirectObjects.get(ref) : ref; + if (!result || result === PDFNull_default && !preservePDFNull) + return void 0; + for (var idx = 0, len = types.length; idx < len; idx++) { + var type = types[idx]; + if (type === PDFNull_default) { + if (result === PDFNull_default) + return result; + } else { + if (result instanceof type) + return result; + } + } + throw new UnexpectedObjectTypeError(types, result); + }; + PDFContext2.prototype.lookup = function(ref) { + var types = []; + for (var _i = 1; _i < arguments.length; _i++) { + types[_i - 1] = arguments[_i]; + } + var result = ref instanceof PDFRef_default ? this.indirectObjects.get(ref) : ref; + if (types.length === 0) + return result; + for (var idx = 0, len = types.length; idx < len; idx++) { + var type = types[idx]; + if (type === PDFNull_default) { + if (result === PDFNull_default) + return result; + } else { + if (result instanceof type) + return result; + } + } + throw new UnexpectedObjectTypeError(types, result); + }; + PDFContext2.prototype.getObjectRef = function(pdfObject) { + var entries = Array.from(this.indirectObjects.entries()); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], ref = _a[0], object = _a[1]; + if (object === pdfObject) { + return ref; + } + } + return void 0; + }; + PDFContext2.prototype.enumerateIndirectObjects = function() { + return Array.from(this.indirectObjects.entries()).sort(byAscendingObjectNumber); + }; + PDFContext2.prototype.obj = function(literal) { + if (literal instanceof PDFObject_default) { + return literal; + } else if (literal === null || literal === void 0) { + return PDFNull_default; + } else if (typeof literal === "string") { + return PDFName_default.of(literal); + } else if (typeof literal === "number") { + return PDFNumber_default.of(literal); + } else if (typeof literal === "boolean") { + return literal ? PDFBool_default.True : PDFBool_default.False; + } else if (Array.isArray(literal)) { + var array = PDFArray_default.withContext(this); + for (var idx = 0, len = literal.length; idx < len; idx++) { + array.push(this.obj(literal[idx])); + } + return array; + } else { + var dict = PDFDict_default.withContext(this); + var keys = Object.keys(literal); + for (var idx = 0, len = keys.length; idx < len; idx++) { + var key = keys[idx]; + var value = literal[key]; + if (value !== void 0) + dict.set(PDFName_default.of(key), this.obj(value)); + } + return dict; + } + }; + PDFContext2.prototype.stream = function(contents, dict) { + if (dict === void 0) { + dict = {}; + } + return PDFRawStream_default.of(this.obj(dict), typedArrayFor(contents)); + }; + PDFContext2.prototype.flateStream = function(contents, dict) { + if (dict === void 0) { + dict = {}; + } + return this.stream(import_pako3.default.deflate(typedArrayFor(contents)), __assign(__assign({}, dict), { Filter: "FlateDecode" })); + }; + PDFContext2.prototype.contentStream = function(operators, dict) { + if (dict === void 0) { + dict = {}; + } + return PDFContentStream_default.of(this.obj(dict), operators); + }; + PDFContext2.prototype.formXObject = function(operators, dict) { + if (dict === void 0) { + dict = {}; + } + return this.contentStream(operators, __assign(__assign({ BBox: this.obj([0, 0, 0, 0]), Matrix: this.obj([1, 0, 0, 1, 0, 0]) }, dict), { Type: "XObject", Subtype: "Form" })); + }; + PDFContext2.prototype.getPushGraphicsStateContentStream = function() { + if (this.pushGraphicsStateContentStreamRef) { + return this.pushGraphicsStateContentStreamRef; + } + var dict = this.obj({}); + var op = PDFOperator_default.of(PDFOperatorNames_default.PushGraphicsState); + var stream2 = PDFContentStream_default.of(dict, [op]); + this.pushGraphicsStateContentStreamRef = this.register(stream2); + return this.pushGraphicsStateContentStreamRef; + }; + PDFContext2.prototype.getPopGraphicsStateContentStream = function() { + if (this.popGraphicsStateContentStreamRef) { + return this.popGraphicsStateContentStreamRef; + } + var dict = this.obj({}); + var op = PDFOperator_default.of(PDFOperatorNames_default.PopGraphicsState); + var stream2 = PDFContentStream_default.of(dict, [op]); + this.popGraphicsStateContentStreamRef = this.register(stream2); + return this.popGraphicsStateContentStreamRef; + }; + PDFContext2.prototype.addRandomSuffix = function(prefix, suffixLength) { + if (suffixLength === void 0) { + suffixLength = 4; + } + return prefix + "-" + Math.floor(this.rng.nextInt() * Math.pow(10, suffixLength)); + }; + PDFContext2.create = function() { + return new PDFContext2(); + }; + return PDFContext2; + }() +); +var PDFContext_default = PDFContext; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFPageLeaf.js +var PDFPageLeaf = ( + /** @class */ + function(_super) { + __extends(PDFPageLeaf2, _super); + function PDFPageLeaf2(map, context, autoNormalizeCTM) { + if (autoNormalizeCTM === void 0) { + autoNormalizeCTM = true; + } + var _this = _super.call(this, map, context) || this; + _this.normalized = false; + _this.autoNormalizeCTM = autoNormalizeCTM; + return _this; + } + PDFPageLeaf2.prototype.clone = function(context) { + var clone = PDFPageLeaf2.fromMapWithContext(/* @__PURE__ */ new Map(), context || this.context, this.autoNormalizeCTM); + var entries = this.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + clone.set(key, value); + } + return clone; + }; + PDFPageLeaf2.prototype.Parent = function() { + return this.lookupMaybe(PDFName_default.Parent, PDFDict_default); + }; + PDFPageLeaf2.prototype.Contents = function() { + return this.lookup(PDFName_default.of("Contents")); + }; + PDFPageLeaf2.prototype.Annots = function() { + return this.lookupMaybe(PDFName_default.Annots, PDFArray_default); + }; + PDFPageLeaf2.prototype.BleedBox = function() { + return this.lookupMaybe(PDFName_default.BleedBox, PDFArray_default); + }; + PDFPageLeaf2.prototype.TrimBox = function() { + return this.lookupMaybe(PDFName_default.TrimBox, PDFArray_default); + }; + PDFPageLeaf2.prototype.ArtBox = function() { + return this.lookupMaybe(PDFName_default.ArtBox, PDFArray_default); + }; + PDFPageLeaf2.prototype.Resources = function() { + var dictOrRef = this.getInheritableAttribute(PDFName_default.Resources); + return this.context.lookupMaybe(dictOrRef, PDFDict_default); + }; + PDFPageLeaf2.prototype.MediaBox = function() { + var arrayOrRef = this.getInheritableAttribute(PDFName_default.MediaBox); + return this.context.lookup(arrayOrRef, PDFArray_default); + }; + PDFPageLeaf2.prototype.CropBox = function() { + var arrayOrRef = this.getInheritableAttribute(PDFName_default.CropBox); + return this.context.lookupMaybe(arrayOrRef, PDFArray_default); + }; + PDFPageLeaf2.prototype.Rotate = function() { + var numberOrRef = this.getInheritableAttribute(PDFName_default.Rotate); + return this.context.lookupMaybe(numberOrRef, PDFNumber_default); + }; + PDFPageLeaf2.prototype.getInheritableAttribute = function(name) { + var attribute; + this.ascend(function(node) { + if (!attribute) + attribute = node.get(name); + }); + return attribute; + }; + PDFPageLeaf2.prototype.setParent = function(parentRef) { + this.set(PDFName_default.Parent, parentRef); + }; + PDFPageLeaf2.prototype.addContentStream = function(contentStreamRef) { + var Contents = this.normalizedEntries().Contents || this.context.obj([]); + this.set(PDFName_default.Contents, Contents); + Contents.push(contentStreamRef); + }; + PDFPageLeaf2.prototype.wrapContentStreams = function(startStream, endStream) { + var Contents = this.Contents(); + if (Contents instanceof PDFArray_default) { + Contents.insert(0, startStream); + Contents.push(endStream); + return true; + } + return false; + }; + PDFPageLeaf2.prototype.addAnnot = function(annotRef) { + var Annots = this.normalizedEntries().Annots; + Annots.push(annotRef); + }; + PDFPageLeaf2.prototype.removeAnnot = function(annotRef) { + var Annots = this.normalizedEntries().Annots; + var index = Annots.indexOf(annotRef); + if (index !== void 0) { + Annots.remove(index); + } + }; + PDFPageLeaf2.prototype.setFontDictionary = function(name, fontDictRef) { + var Font2 = this.normalizedEntries().Font; + Font2.set(name, fontDictRef); + }; + PDFPageLeaf2.prototype.newFontDictionaryKey = function(tag) { + var Font2 = this.normalizedEntries().Font; + return Font2.uniqueKey(tag); + }; + PDFPageLeaf2.prototype.newFontDictionary = function(tag, fontDictRef) { + var key = this.newFontDictionaryKey(tag); + this.setFontDictionary(key, fontDictRef); + return key; + }; + PDFPageLeaf2.prototype.setXObject = function(name, xObjectRef) { + var XObject = this.normalizedEntries().XObject; + XObject.set(name, xObjectRef); + }; + PDFPageLeaf2.prototype.newXObjectKey = function(tag) { + var XObject = this.normalizedEntries().XObject; + return XObject.uniqueKey(tag); + }; + PDFPageLeaf2.prototype.newXObject = function(tag, xObjectRef) { + var key = this.newXObjectKey(tag); + this.setXObject(key, xObjectRef); + return key; + }; + PDFPageLeaf2.prototype.setExtGState = function(name, extGStateRef) { + var ExtGState = this.normalizedEntries().ExtGState; + ExtGState.set(name, extGStateRef); + }; + PDFPageLeaf2.prototype.newExtGStateKey = function(tag) { + var ExtGState = this.normalizedEntries().ExtGState; + return ExtGState.uniqueKey(tag); + }; + PDFPageLeaf2.prototype.newExtGState = function(tag, extGStateRef) { + var key = this.newExtGStateKey(tag); + this.setExtGState(key, extGStateRef); + return key; + }; + PDFPageLeaf2.prototype.ascend = function(visitor) { + visitor(this); + var Parent = this.Parent(); + if (Parent) + Parent.ascend(visitor); + }; + PDFPageLeaf2.prototype.normalize = function() { + if (this.normalized) + return; + var context = this.context; + var contentsRef = this.get(PDFName_default.Contents); + var contents = this.context.lookup(contentsRef); + if (contents instanceof PDFStream_default) { + this.set(PDFName_default.Contents, context.obj([contentsRef])); + } + if (this.autoNormalizeCTM) { + this.wrapContentStreams(this.context.getPushGraphicsStateContentStream(), this.context.getPopGraphicsStateContentStream()); + } + var dictOrRef = this.getInheritableAttribute(PDFName_default.Resources); + var Resources = context.lookupMaybe(dictOrRef, PDFDict_default) || context.obj({}); + this.set(PDFName_default.Resources, Resources); + var Font2 = Resources.lookupMaybe(PDFName_default.Font, PDFDict_default) || context.obj({}); + Resources.set(PDFName_default.Font, Font2); + var XObject = Resources.lookupMaybe(PDFName_default.XObject, PDFDict_default) || context.obj({}); + Resources.set(PDFName_default.XObject, XObject); + var ExtGState = Resources.lookupMaybe(PDFName_default.ExtGState, PDFDict_default) || context.obj({}); + Resources.set(PDFName_default.ExtGState, ExtGState); + var Annots = this.Annots() || context.obj([]); + this.set(PDFName_default.Annots, Annots); + this.normalized = true; + }; + PDFPageLeaf2.prototype.normalizedEntries = function() { + this.normalize(); + var Annots = this.Annots(); + var Resources = this.Resources(); + var Contents = this.Contents(); + return { + Annots, + Resources, + Contents, + Font: Resources.lookup(PDFName_default.Font, PDFDict_default), + XObject: Resources.lookup(PDFName_default.XObject, PDFDict_default), + ExtGState: Resources.lookup(PDFName_default.ExtGState, PDFDict_default) + }; + }; + PDFPageLeaf2.InheritableEntries = [ + "Resources", + "MediaBox", + "CropBox", + "Rotate" + ]; + PDFPageLeaf2.withContextAndParent = function(context, parent) { + var dict = /* @__PURE__ */ new Map(); + dict.set(PDFName_default.Type, PDFName_default.Page); + dict.set(PDFName_default.Parent, parent); + dict.set(PDFName_default.Resources, context.obj({})); + dict.set(PDFName_default.MediaBox, context.obj([0, 0, 612, 792])); + return new PDFPageLeaf2(dict, context, false); + }; + PDFPageLeaf2.fromMapWithContext = function(map, context, autoNormalizeCTM) { + if (autoNormalizeCTM === void 0) { + autoNormalizeCTM = true; + } + return new PDFPageLeaf2(map, context, autoNormalizeCTM); + }; + return PDFPageLeaf2; + }(PDFDict_default) +); +var PDFPageLeaf_default = PDFPageLeaf; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/PDFObjectCopier.js +var PDFObjectCopier = ( + /** @class */ + function() { + function PDFObjectCopier2(src, dest) { + var _this = this; + this.traversedObjects = /* @__PURE__ */ new Map(); + this.copy = function(object) { + return object instanceof PDFPageLeaf_default ? _this.copyPDFPage(object) : object instanceof PDFDict_default ? _this.copyPDFDict(object) : object instanceof PDFArray_default ? _this.copyPDFArray(object) : object instanceof PDFStream_default ? _this.copyPDFStream(object) : object instanceof PDFRef_default ? _this.copyPDFIndirectObject(object) : object.clone(); + }; + this.copyPDFPage = function(originalPage) { + var clonedPage = originalPage.clone(); + var InheritableEntries = PDFPageLeaf_default.InheritableEntries; + for (var idx = 0, len = InheritableEntries.length; idx < len; idx++) { + var key = PDFName_default.of(InheritableEntries[idx]); + var value = clonedPage.getInheritableAttribute(key); + if (!clonedPage.get(key) && value) + clonedPage.set(key, value); + } + clonedPage.delete(PDFName_default.of("Parent")); + return _this.copyPDFDict(clonedPage); + }; + this.copyPDFDict = function(originalDict) { + if (_this.traversedObjects.has(originalDict)) { + return _this.traversedObjects.get(originalDict); + } + var clonedDict = originalDict.clone(_this.dest); + _this.traversedObjects.set(originalDict, clonedDict); + var entries = originalDict.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + clonedDict.set(key, _this.copy(value)); + } + return clonedDict; + }; + this.copyPDFArray = function(originalArray) { + if (_this.traversedObjects.has(originalArray)) { + return _this.traversedObjects.get(originalArray); + } + var clonedArray = originalArray.clone(_this.dest); + _this.traversedObjects.set(originalArray, clonedArray); + for (var idx = 0, len = originalArray.size(); idx < len; idx++) { + var value = originalArray.get(idx); + clonedArray.set(idx, _this.copy(value)); + } + return clonedArray; + }; + this.copyPDFStream = function(originalStream) { + if (_this.traversedObjects.has(originalStream)) { + return _this.traversedObjects.get(originalStream); + } + var clonedStream = originalStream.clone(_this.dest); + _this.traversedObjects.set(originalStream, clonedStream); + var entries = originalStream.dict.entries(); + for (var idx = 0, len = entries.length; idx < len; idx++) { + var _a = entries[idx], key = _a[0], value = _a[1]; + clonedStream.dict.set(key, _this.copy(value)); + } + return clonedStream; + }; + this.copyPDFIndirectObject = function(ref) { + var alreadyMapped = _this.traversedObjects.has(ref); + if (!alreadyMapped) { + var newRef = _this.dest.nextRef(); + _this.traversedObjects.set(ref, newRef); + var dereferencedValue = _this.src.lookup(ref); + if (dereferencedValue) { + var cloned = _this.copy(dereferencedValue); + _this.dest.assign(newRef, cloned); + } + } + return _this.traversedObjects.get(ref); + }; + this.src = src; + this.dest = dest; + } + PDFObjectCopier2.for = function(src, dest) { + return new PDFObjectCopier2(src, dest); + }; + return PDFObjectCopier2; + }() +); +var PDFObjectCopier_default = PDFObjectCopier; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/document/PDFCrossRefSection.js +var PDFCrossRefSection = ( + /** @class */ + function() { + function PDFCrossRefSection2(firstEntry) { + this.subsections = firstEntry ? [[firstEntry]] : []; + this.chunkIdx = 0; + this.chunkLength = firstEntry ? 1 : 0; + } + PDFCrossRefSection2.prototype.addEntry = function(ref, offset) { + this.append({ ref, offset, deleted: false }); + }; + PDFCrossRefSection2.prototype.addDeletedEntry = function(ref, nextFreeObjectNumber) { + this.append({ ref, offset: nextFreeObjectNumber, deleted: true }); + }; + PDFCrossRefSection2.prototype.toString = function() { + var section = "xref\n"; + for (var rangeIdx = 0, rangeLen = this.subsections.length; rangeIdx < rangeLen; rangeIdx++) { + var range2 = this.subsections[rangeIdx]; + section += range2[0].ref.objectNumber + " " + range2.length + "\n"; + for (var entryIdx = 0, entryLen = range2.length; entryIdx < entryLen; entryIdx++) { + var entry = range2[entryIdx]; + section += padStart(String(entry.offset), 10, "0"); + section += " "; + section += padStart(String(entry.ref.generationNumber), 5, "0"); + section += " "; + section += entry.deleted ? "f" : "n"; + section += " \n"; + } + } + return section; + }; + PDFCrossRefSection2.prototype.sizeInBytes = function() { + var size = 5; + for (var idx = 0, len = this.subsections.length; idx < len; idx++) { + var subsection = this.subsections[idx]; + var subsectionLength = subsection.length; + var firstEntry = subsection[0]; + size += 2; + size += String(firstEntry.ref.objectNumber).length; + size += String(subsectionLength).length; + size += 20 * subsectionLength; + } + return size; + }; + PDFCrossRefSection2.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + buffer[offset++] = CharCodes_default.x; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.f; + buffer[offset++] = CharCodes_default.Newline; + offset += this.copySubsectionsIntoBuffer(this.subsections, buffer, offset); + return offset - initialOffset; + }; + PDFCrossRefSection2.prototype.copySubsectionsIntoBuffer = function(subsections, buffer, offset) { + var initialOffset = offset; + var length = subsections.length; + for (var idx = 0; idx < length; idx++) { + var subsection = this.subsections[idx]; + var firstObjectNumber = String(subsection[0].ref.objectNumber); + offset += copyStringIntoBuffer(firstObjectNumber, buffer, offset); + buffer[offset++] = CharCodes_default.Space; + var rangeLength = String(subsection.length); + offset += copyStringIntoBuffer(rangeLength, buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + offset += this.copyEntriesIntoBuffer(subsection, buffer, offset); + } + return offset - initialOffset; + }; + PDFCrossRefSection2.prototype.copyEntriesIntoBuffer = function(entries, buffer, offset) { + var length = entries.length; + for (var idx = 0; idx < length; idx++) { + var entry = entries[idx]; + var entryOffset = padStart(String(entry.offset), 10, "0"); + offset += copyStringIntoBuffer(entryOffset, buffer, offset); + buffer[offset++] = CharCodes_default.Space; + var entryGen = padStart(String(entry.ref.generationNumber), 5, "0"); + offset += copyStringIntoBuffer(entryGen, buffer, offset); + buffer[offset++] = CharCodes_default.Space; + buffer[offset++] = entry.deleted ? CharCodes_default.f : CharCodes_default.n; + buffer[offset++] = CharCodes_default.Space; + buffer[offset++] = CharCodes_default.Newline; + } + return 20 * length; + }; + PDFCrossRefSection2.prototype.append = function(currEntry) { + if (this.chunkLength === 0) { + this.subsections.push([currEntry]); + this.chunkIdx = 0; + this.chunkLength = 1; + return; + } + var chunk = this.subsections[this.chunkIdx]; + var prevEntry = chunk[this.chunkLength - 1]; + if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) { + this.subsections.push([currEntry]); + this.chunkIdx += 1; + this.chunkLength = 1; + } else { + chunk.push(currEntry); + this.chunkLength += 1; + } + }; + PDFCrossRefSection2.create = function() { + return new PDFCrossRefSection2({ + ref: PDFRef_default.of(0, 65535), + offset: 0, + deleted: true + }); + }; + PDFCrossRefSection2.createEmpty = function() { + return new PDFCrossRefSection2(); + }; + return PDFCrossRefSection2; + }() +); +var PDFCrossRefSection_default = PDFCrossRefSection; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/document/PDFTrailer.js +var PDFTrailer = ( + /** @class */ + function() { + function PDFTrailer2(lastXRefOffset) { + this.lastXRefOffset = String(lastXRefOffset); + } + PDFTrailer2.prototype.toString = function() { + return "startxref\n" + this.lastXRefOffset + "\n%%EOF"; + }; + PDFTrailer2.prototype.sizeInBytes = function() { + return 16 + this.lastXRefOffset.length; + }; + PDFTrailer2.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + buffer[offset++] = CharCodes_default.s; + buffer[offset++] = CharCodes_default.t; + buffer[offset++] = CharCodes_default.a; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.t; + buffer[offset++] = CharCodes_default.x; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.f; + buffer[offset++] = CharCodes_default.Newline; + offset += copyStringIntoBuffer(this.lastXRefOffset, buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.Percent; + buffer[offset++] = CharCodes_default.Percent; + buffer[offset++] = CharCodes_default.E; + buffer[offset++] = CharCodes_default.O; + buffer[offset++] = CharCodes_default.F; + return offset - initialOffset; + }; + PDFTrailer2.forLastCrossRefSectionOffset = function(offset) { + return new PDFTrailer2(offset); + }; + return PDFTrailer2; + }() +); +var PDFTrailer_default = PDFTrailer; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/document/PDFTrailerDict.js +var PDFTrailerDict = ( + /** @class */ + function() { + function PDFTrailerDict2(dict) { + this.dict = dict; + } + PDFTrailerDict2.prototype.toString = function() { + return "trailer\n" + this.dict.toString(); + }; + PDFTrailerDict2.prototype.sizeInBytes = function() { + return 8 + this.dict.sizeInBytes(); + }; + PDFTrailerDict2.prototype.copyBytesInto = function(buffer, offset) { + var initialOffset = offset; + buffer[offset++] = CharCodes_default.t; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.a; + buffer[offset++] = CharCodes_default.i; + buffer[offset++] = CharCodes_default.l; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.r; + buffer[offset++] = CharCodes_default.Newline; + offset += this.dict.copyBytesInto(buffer, offset); + return offset - initialOffset; + }; + PDFTrailerDict2.of = function(dict) { + return new PDFTrailerDict2(dict); + }; + return PDFTrailerDict2; + }() +); +var PDFTrailerDict_default = PDFTrailerDict; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFObjectStream.js +var PDFObjectStream = ( + /** @class */ + function(_super) { + __extends(PDFObjectStream2, _super); + function PDFObjectStream2(context, objects, encode) { + if (encode === void 0) { + encode = true; + } + var _this = _super.call(this, context.obj({}), encode) || this; + _this.objects = objects; + _this.offsets = _this.computeObjectOffsets(); + _this.offsetsString = _this.computeOffsetsString(); + _this.dict.set(PDFName_default.of("Type"), PDFName_default.of("ObjStm")); + _this.dict.set(PDFName_default.of("N"), PDFNumber_default.of(_this.objects.length)); + _this.dict.set(PDFName_default.of("First"), PDFNumber_default.of(_this.offsetsString.length)); + return _this; + } + PDFObjectStream2.prototype.getObjectsCount = function() { + return this.objects.length; + }; + PDFObjectStream2.prototype.clone = function(context) { + return PDFObjectStream2.withContextAndObjects(context || this.dict.context, this.objects.slice(), this.encode); + }; + PDFObjectStream2.prototype.getContentsString = function() { + var value = this.offsetsString; + for (var idx = 0, len = this.objects.length; idx < len; idx++) { + var _a = this.objects[idx], object = _a[1]; + value += object + "\n"; + } + return value; + }; + PDFObjectStream2.prototype.getUnencodedContents = function() { + var buffer = new Uint8Array(this.getUnencodedContentsSize()); + var offset = copyStringIntoBuffer(this.offsetsString, buffer, 0); + for (var idx = 0, len = this.objects.length; idx < len; idx++) { + var _a = this.objects[idx], object = _a[1]; + offset += object.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + } + return buffer; + }; + PDFObjectStream2.prototype.getUnencodedContentsSize = function() { + return this.offsetsString.length + last(this.offsets)[1] + last(this.objects)[1].sizeInBytes() + 1; + }; + PDFObjectStream2.prototype.computeOffsetsString = function() { + var offsetsString = ""; + for (var idx = 0, len = this.offsets.length; idx < len; idx++) { + var _a = this.offsets[idx], objectNumber = _a[0], offset = _a[1]; + offsetsString += objectNumber + " " + offset + " "; + } + return offsetsString; + }; + PDFObjectStream2.prototype.computeObjectOffsets = function() { + var offset = 0; + var offsets = new Array(this.objects.length); + for (var idx = 0, len = this.objects.length; idx < len; idx++) { + var _a = this.objects[idx], ref = _a[0], object = _a[1]; + offsets[idx] = [ref.objectNumber, offset]; + offset += object.sizeInBytes() + 1; + } + return offsets; + }; + PDFObjectStream2.withContextAndObjects = function(context, objects, encode) { + if (encode === void 0) { + encode = true; + } + return new PDFObjectStream2(context, objects, encode); + }; + return PDFObjectStream2; + }(PDFFlateStream_default) +); +var PDFObjectStream_default = PDFObjectStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/writers/PDFWriter.js +var PDFWriter = ( + /** @class */ + function() { + function PDFWriter2(context, objectsPerTick) { + var _this = this; + this.parsedObjects = 0; + this.shouldWaitForTick = function(n) { + _this.parsedObjects += n; + return _this.parsedObjects % _this.objectsPerTick === 0; + }; + this.context = context; + this.objectsPerTick = objectsPerTick; + } + PDFWriter2.prototype.serializeToBuffer = function() { + return __awaiter(this, void 0, void 0, function() { + var _a, size, header, indirectObjects, xref, trailerDict, trailer, offset, buffer, idx, len, _b, ref, object, objectNumber, generationNumber, n; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + return [4, this.computeBufferSize()]; + case 1: + _a = _c.sent(), size = _a.size, header = _a.header, indirectObjects = _a.indirectObjects, xref = _a.xref, trailerDict = _a.trailerDict, trailer = _a.trailer; + offset = 0; + buffer = new Uint8Array(size); + offset += header.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.Newline; + idx = 0, len = indirectObjects.length; + _c.label = 2; + case 2: + if (!(idx < len)) return [3, 5]; + _b = indirectObjects[idx], ref = _b[0], object = _b[1]; + objectNumber = String(ref.objectNumber); + offset += copyStringIntoBuffer(objectNumber, buffer, offset); + buffer[offset++] = CharCodes_default.Space; + generationNumber = String(ref.generationNumber); + offset += copyStringIntoBuffer(generationNumber, buffer, offset); + buffer[offset++] = CharCodes_default.Space; + buffer[offset++] = CharCodes_default.o; + buffer[offset++] = CharCodes_default.b; + buffer[offset++] = CharCodes_default.j; + buffer[offset++] = CharCodes_default.Newline; + offset += object.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.e; + buffer[offset++] = CharCodes_default.n; + buffer[offset++] = CharCodes_default.d; + buffer[offset++] = CharCodes_default.o; + buffer[offset++] = CharCodes_default.b; + buffer[offset++] = CharCodes_default.j; + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.Newline; + n = object instanceof PDFObjectStream_default ? object.getObjectsCount() : 1; + if (!this.shouldWaitForTick(n)) return [3, 4]; + return [4, waitForTick()]; + case 3: + _c.sent(); + _c.label = 4; + case 4: + idx++; + return [3, 2]; + case 5: + if (xref) { + offset += xref.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + } + if (trailerDict) { + offset += trailerDict.copyBytesInto(buffer, offset); + buffer[offset++] = CharCodes_default.Newline; + buffer[offset++] = CharCodes_default.Newline; + } + offset += trailer.copyBytesInto(buffer, offset); + return [2, buffer]; + } + }); + }); + }; + PDFWriter2.prototype.computeIndirectObjectSize = function(_a) { + var ref = _a[0], object = _a[1]; + var refSize = ref.sizeInBytes() + 3; + var objectSize = object.sizeInBytes() + 9; + return refSize + objectSize; + }; + PDFWriter2.prototype.createTrailerDict = function() { + return this.context.obj({ + Size: this.context.largestObjectNumber + 1, + Root: this.context.trailerInfo.Root, + Encrypt: this.context.trailerInfo.Encrypt, + Info: this.context.trailerInfo.Info, + ID: this.context.trailerInfo.ID + }); + }; + PDFWriter2.prototype.computeBufferSize = function() { + return __awaiter(this, void 0, void 0, function() { + var header, size, xref, indirectObjects, idx, len, indirectObject, ref, xrefOffset, trailerDict, trailer; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + header = PDFHeader_default.forVersion(1, 7); + size = header.sizeInBytes() + 2; + xref = PDFCrossRefSection_default.create(); + indirectObjects = this.context.enumerateIndirectObjects(); + idx = 0, len = indirectObjects.length; + _a.label = 1; + case 1: + if (!(idx < len)) return [3, 4]; + indirectObject = indirectObjects[idx]; + ref = indirectObject[0]; + xref.addEntry(ref, size); + size += this.computeIndirectObjectSize(indirectObject); + if (!this.shouldWaitForTick(1)) return [3, 3]; + return [4, waitForTick()]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + idx++; + return [3, 1]; + case 4: + xrefOffset = size; + size += xref.sizeInBytes() + 1; + trailerDict = PDFTrailerDict_default.of(this.createTrailerDict()); + size += trailerDict.sizeInBytes() + 2; + trailer = PDFTrailer_default.forLastCrossRefSectionOffset(xrefOffset); + size += trailer.sizeInBytes(); + return [2, { size, header, indirectObjects, xref, trailerDict, trailer }]; + } + }); + }); + }; + PDFWriter2.forContext = function(context, objectsPerTick) { + return new PDFWriter2(context, objectsPerTick); + }; + return PDFWriter2; + }() +); +var PDFWriter_default = PDFWriter; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFInvalidObject.js +var PDFInvalidObject = ( + /** @class */ + function(_super) { + __extends(PDFInvalidObject2, _super); + function PDFInvalidObject2(data) { + var _this = _super.call(this) || this; + _this.data = data; + return _this; + } + PDFInvalidObject2.prototype.clone = function() { + return PDFInvalidObject2.of(this.data.slice()); + }; + PDFInvalidObject2.prototype.toString = function() { + return "PDFInvalidObject(" + this.data.length + " bytes)"; + }; + PDFInvalidObject2.prototype.sizeInBytes = function() { + return this.data.length; + }; + PDFInvalidObject2.prototype.copyBytesInto = function(buffer, offset) { + var length = this.data.length; + for (var idx = 0; idx < length; idx++) { + buffer[offset++] = this.data[idx]; + } + return length; + }; + PDFInvalidObject2.of = function(data) { + return new PDFInvalidObject2(data); + }; + return PDFInvalidObject2; + }(PDFObject_default) +); +var PDFInvalidObject_default = PDFInvalidObject; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFCrossRefStream.js +var EntryType; +(function(EntryType2) { + EntryType2[EntryType2["Deleted"] = 0] = "Deleted"; + EntryType2[EntryType2["Uncompressed"] = 1] = "Uncompressed"; + EntryType2[EntryType2["Compressed"] = 2] = "Compressed"; +})(EntryType || (EntryType = {})); +var PDFCrossRefStream = ( + /** @class */ + function(_super) { + __extends(PDFCrossRefStream2, _super); + function PDFCrossRefStream2(dict, entries, encode) { + if (encode === void 0) { + encode = true; + } + var _this = _super.call(this, dict, encode) || this; + _this.computeIndex = function() { + var subsections = []; + var subsectionLength = 0; + for (var idx = 0, len = _this.entries.length; idx < len; idx++) { + var currEntry = _this.entries[idx]; + var prevEntry = _this.entries[idx - 1]; + if (idx === 0) { + subsections.push(currEntry.ref.objectNumber); + } else if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) { + subsections.push(subsectionLength); + subsections.push(currEntry.ref.objectNumber); + subsectionLength = 0; + } + subsectionLength += 1; + } + subsections.push(subsectionLength); + return subsections; + }; + _this.computeEntryTuples = function() { + var entryTuples = new Array(_this.entries.length); + for (var idx = 0, len = _this.entries.length; idx < len; idx++) { + var entry = _this.entries[idx]; + if (entry.type === EntryType.Deleted) { + var type = entry.type, nextFreeObjectNumber = entry.nextFreeObjectNumber, ref = entry.ref; + entryTuples[idx] = [type, nextFreeObjectNumber, ref.generationNumber]; + } + if (entry.type === EntryType.Uncompressed) { + var type = entry.type, offset = entry.offset, ref = entry.ref; + entryTuples[idx] = [type, offset, ref.generationNumber]; + } + if (entry.type === EntryType.Compressed) { + var type = entry.type, objectStreamRef = entry.objectStreamRef, index = entry.index; + entryTuples[idx] = [type, objectStreamRef.objectNumber, index]; + } + } + return entryTuples; + }; + _this.computeMaxEntryByteWidths = function() { + var entryTuples = _this.entryTuplesCache.access(); + var widths = [0, 0, 0]; + for (var idx = 0, len = entryTuples.length; idx < len; idx++) { + var _a = entryTuples[idx], first = _a[0], second = _a[1], third = _a[2]; + var firstSize = sizeInBytes(first); + var secondSize = sizeInBytes(second); + var thirdSize = sizeInBytes(third); + if (firstSize > widths[0]) + widths[0] = firstSize; + if (secondSize > widths[1]) + widths[1] = secondSize; + if (thirdSize > widths[2]) + widths[2] = thirdSize; + } + return widths; + }; + _this.entries = entries || []; + _this.entryTuplesCache = Cache_default.populatedBy(_this.computeEntryTuples); + _this.maxByteWidthsCache = Cache_default.populatedBy(_this.computeMaxEntryByteWidths); + _this.indexCache = Cache_default.populatedBy(_this.computeIndex); + dict.set(PDFName_default.of("Type"), PDFName_default.of("XRef")); + return _this; + } + PDFCrossRefStream2.prototype.addDeletedEntry = function(ref, nextFreeObjectNumber) { + var type = EntryType.Deleted; + this.entries.push({ type, ref, nextFreeObjectNumber }); + this.entryTuplesCache.invalidate(); + this.maxByteWidthsCache.invalidate(); + this.indexCache.invalidate(); + this.contentsCache.invalidate(); + }; + PDFCrossRefStream2.prototype.addUncompressedEntry = function(ref, offset) { + var type = EntryType.Uncompressed; + this.entries.push({ type, ref, offset }); + this.entryTuplesCache.invalidate(); + this.maxByteWidthsCache.invalidate(); + this.indexCache.invalidate(); + this.contentsCache.invalidate(); + }; + PDFCrossRefStream2.prototype.addCompressedEntry = function(ref, objectStreamRef, index) { + var type = EntryType.Compressed; + this.entries.push({ type, ref, objectStreamRef, index }); + this.entryTuplesCache.invalidate(); + this.maxByteWidthsCache.invalidate(); + this.indexCache.invalidate(); + this.contentsCache.invalidate(); + }; + PDFCrossRefStream2.prototype.clone = function(context) { + var _a = this, dict = _a.dict, entries = _a.entries, encode = _a.encode; + return PDFCrossRefStream2.of(dict.clone(context), entries.slice(), encode); + }; + PDFCrossRefStream2.prototype.getContentsString = function() { + var entryTuples = this.entryTuplesCache.access(); + var byteWidths = this.maxByteWidthsCache.access(); + var value = ""; + for (var entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) { + var _a = entryTuples[entryIdx], first = _a[0], second = _a[1], third = _a[2]; + var firstBytes = reverseArray(bytesFor(first)); + var secondBytes = reverseArray(bytesFor(second)); + var thirdBytes = reverseArray(bytesFor(third)); + for (var idx = byteWidths[0] - 1; idx >= 0; idx--) { + value += (firstBytes[idx] || 0).toString(2); + } + for (var idx = byteWidths[1] - 1; idx >= 0; idx--) { + value += (secondBytes[idx] || 0).toString(2); + } + for (var idx = byteWidths[2] - 1; idx >= 0; idx--) { + value += (thirdBytes[idx] || 0).toString(2); + } + } + return value; + }; + PDFCrossRefStream2.prototype.getUnencodedContents = function() { + var entryTuples = this.entryTuplesCache.access(); + var byteWidths = this.maxByteWidthsCache.access(); + var buffer = new Uint8Array(this.getUnencodedContentsSize()); + var offset = 0; + for (var entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) { + var _a = entryTuples[entryIdx], first = _a[0], second = _a[1], third = _a[2]; + var firstBytes = reverseArray(bytesFor(first)); + var secondBytes = reverseArray(bytesFor(second)); + var thirdBytes = reverseArray(bytesFor(third)); + for (var idx = byteWidths[0] - 1; idx >= 0; idx--) { + buffer[offset++] = firstBytes[idx] || 0; + } + for (var idx = byteWidths[1] - 1; idx >= 0; idx--) { + buffer[offset++] = secondBytes[idx] || 0; + } + for (var idx = byteWidths[2] - 1; idx >= 0; idx--) { + buffer[offset++] = thirdBytes[idx] || 0; + } + } + return buffer; + }; + PDFCrossRefStream2.prototype.getUnencodedContentsSize = function() { + var byteWidths = this.maxByteWidthsCache.access(); + var entryWidth = sum(byteWidths); + return entryWidth * this.entries.length; + }; + PDFCrossRefStream2.prototype.updateDict = function() { + _super.prototype.updateDict.call(this); + var byteWidths = this.maxByteWidthsCache.access(); + var index = this.indexCache.access(); + var context = this.dict.context; + this.dict.set(PDFName_default.of("W"), context.obj(byteWidths)); + this.dict.set(PDFName_default.of("Index"), context.obj(index)); + }; + PDFCrossRefStream2.create = function(dict, encode) { + if (encode === void 0) { + encode = true; + } + var stream2 = new PDFCrossRefStream2(dict, [], encode); + stream2.addDeletedEntry(PDFRef_default.of(0, 65535), 0); + return stream2; + }; + PDFCrossRefStream2.of = function(dict, entries, encode) { + if (encode === void 0) { + encode = true; + } + return new PDFCrossRefStream2(dict, entries, encode); + }; + return PDFCrossRefStream2; + }(PDFFlateStream_default) +); +var PDFCrossRefStream_default = PDFCrossRefStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/writers/PDFStreamWriter.js +var PDFStreamWriter = ( + /** @class */ + function(_super) { + __extends(PDFStreamWriter2, _super); + function PDFStreamWriter2(context, objectsPerTick, encodeStreams, objectsPerStream) { + var _this = _super.call(this, context, objectsPerTick) || this; + _this.encodeStreams = encodeStreams; + _this.objectsPerStream = objectsPerStream; + return _this; + } + PDFStreamWriter2.prototype.computeBufferSize = function() { + return __awaiter(this, void 0, void 0, function() { + var objectNumber, header, size, xrefStream, uncompressedObjects, compressedObjects, objectStreamRefs, indirectObjects, idx, len, indirectObject, ref, object, shouldNotCompress, chunk, objectStreamRef, idx, len, chunk, ref, objectStream, xrefStreamRef, xrefOffset, trailer; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + objectNumber = this.context.largestObjectNumber + 1; + header = PDFHeader_default.forVersion(1, 7); + size = header.sizeInBytes() + 2; + xrefStream = PDFCrossRefStream_default.create(this.createTrailerDict(), this.encodeStreams); + uncompressedObjects = []; + compressedObjects = []; + objectStreamRefs = []; + indirectObjects = this.context.enumerateIndirectObjects(); + idx = 0, len = indirectObjects.length; + _a.label = 1; + case 1: + if (!(idx < len)) return [3, 6]; + indirectObject = indirectObjects[idx]; + ref = indirectObject[0], object = indirectObject[1]; + shouldNotCompress = ref === this.context.trailerInfo.Encrypt || object instanceof PDFStream_default || object instanceof PDFInvalidObject_default || ref.generationNumber !== 0; + if (!shouldNotCompress) return [3, 4]; + uncompressedObjects.push(indirectObject); + xrefStream.addUncompressedEntry(ref, size); + size += this.computeIndirectObjectSize(indirectObject); + if (!this.shouldWaitForTick(1)) return [3, 3]; + return [4, waitForTick()]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + return [3, 5]; + case 4: + chunk = last(compressedObjects); + objectStreamRef = last(objectStreamRefs); + if (!chunk || chunk.length % this.objectsPerStream === 0) { + chunk = []; + compressedObjects.push(chunk); + objectStreamRef = PDFRef_default.of(objectNumber++); + objectStreamRefs.push(objectStreamRef); + } + xrefStream.addCompressedEntry(ref, objectStreamRef, chunk.length); + chunk.push(indirectObject); + _a.label = 5; + case 5: + idx++; + return [3, 1]; + case 6: + idx = 0, len = compressedObjects.length; + _a.label = 7; + case 7: + if (!(idx < len)) return [3, 10]; + chunk = compressedObjects[idx]; + ref = objectStreamRefs[idx]; + objectStream = PDFObjectStream_default.withContextAndObjects(this.context, chunk, this.encodeStreams); + xrefStream.addUncompressedEntry(ref, size); + size += this.computeIndirectObjectSize([ref, objectStream]); + uncompressedObjects.push([ref, objectStream]); + if (!this.shouldWaitForTick(chunk.length)) return [3, 9]; + return [4, waitForTick()]; + case 8: + _a.sent(); + _a.label = 9; + case 9: + idx++; + return [3, 7]; + case 10: + xrefStreamRef = PDFRef_default.of(objectNumber++); + xrefStream.dict.set(PDFName_default.of("Size"), PDFNumber_default.of(objectNumber)); + xrefStream.addUncompressedEntry(xrefStreamRef, size); + xrefOffset = size; + size += this.computeIndirectObjectSize([xrefStreamRef, xrefStream]); + uncompressedObjects.push([xrefStreamRef, xrefStream]); + trailer = PDFTrailer_default.forLastCrossRefSectionOffset(xrefOffset); + size += trailer.sizeInBytes(); + return [2, { size, header, indirectObjects: uncompressedObjects, trailer }]; + } + }); + }); + }; + PDFStreamWriter2.forContext = function(context, objectsPerTick, encodeStreams, objectsPerStream) { + if (encodeStreams === void 0) { + encodeStreams = true; + } + if (objectsPerStream === void 0) { + objectsPerStream = 50; + } + return new PDFStreamWriter2(context, objectsPerTick, encodeStreams, objectsPerStream); + }; + return PDFStreamWriter2; + }(PDFWriter_default) +); +var PDFStreamWriter_default = PDFStreamWriter; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFHexString.js +var PDFHexString = ( + /** @class */ + function(_super) { + __extends(PDFHexString2, _super); + function PDFHexString2(value) { + var _this = _super.call(this) || this; + _this.value = value; + return _this; + } + PDFHexString2.prototype.asBytes = function() { + var hex = this.value + (this.value.length % 2 === 1 ? "0" : ""); + var hexLength = hex.length; + var bytes = new Uint8Array(hex.length / 2); + var hexOffset = 0; + var bytesOffset = 0; + while (hexOffset < hexLength) { + var byte = parseInt(hex.substring(hexOffset, hexOffset + 2), 16); + bytes[bytesOffset] = byte; + hexOffset += 2; + bytesOffset += 1; + } + return bytes; + }; + PDFHexString2.prototype.decodeText = function() { + var bytes = this.asBytes(); + if (hasUtf16BOM(bytes)) + return utf16Decode(bytes); + return pdfDocEncodingDecode(bytes); + }; + PDFHexString2.prototype.decodeDate = function() { + var text = this.decodeText(); + var date = parseDate(text); + if (!date) + throw new InvalidPDFDateStringError(text); + return date; + }; + PDFHexString2.prototype.asString = function() { + return this.value; + }; + PDFHexString2.prototype.clone = function() { + return PDFHexString2.of(this.value); + }; + PDFHexString2.prototype.toString = function() { + return "<" + this.value + ">"; + }; + PDFHexString2.prototype.sizeInBytes = function() { + return this.value.length + 2; + }; + PDFHexString2.prototype.copyBytesInto = function(buffer, offset) { + buffer[offset++] = CharCodes_default.LessThan; + offset += copyStringIntoBuffer(this.value, buffer, offset); + buffer[offset++] = CharCodes_default.GreaterThan; + return this.value.length + 2; + }; + PDFHexString2.of = function(value) { + return new PDFHexString2(value); + }; + PDFHexString2.fromText = function(value) { + var encoded = utf16Encode(value); + var hex = ""; + for (var idx = 0, len = encoded.length; idx < len; idx++) { + hex += toHexStringOfMinLength(encoded[idx], 4); + } + return new PDFHexString2(hex); + }; + return PDFHexString2; + }(PDFObject_default) +); +var PDFHexString_default = PDFHexString; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/StandardFontEmbedder.js +var StandardFontEmbedder = ( + /** @class */ + function() { + function StandardFontEmbedder2(fontName, customName) { + this.encoding = fontName === FontNames.ZapfDingbats ? Encodings.ZapfDingbats : fontName === FontNames.Symbol ? Encodings.Symbol : Encodings.WinAnsi; + this.font = Font.load(fontName); + this.fontName = this.font.FontName; + this.customName = customName; + } + StandardFontEmbedder2.prototype.encodeText = function(text) { + var glyphs = this.encodeTextAsGlyphs(text); + var hexCodes = new Array(glyphs.length); + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + hexCodes[idx] = toHexString(glyphs[idx].code); + } + return PDFHexString_default.of(hexCodes.join("")); + }; + StandardFontEmbedder2.prototype.widthOfTextAtSize = function(text, size) { + var glyphs = this.encodeTextAsGlyphs(text); + var totalWidth = 0; + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + var left = glyphs[idx].name; + var right = (glyphs[idx + 1] || {}).name; + var kernAmount = this.font.getXAxisKerningForPair(left, right) || 0; + totalWidth += this.widthOfGlyph(left) + kernAmount; + } + var scale2 = size / 1e3; + return totalWidth * scale2; + }; + StandardFontEmbedder2.prototype.heightOfFontAtSize = function(size, options) { + if (options === void 0) { + options = {}; + } + var _a = options.descender, descender = _a === void 0 ? true : _a; + var _b = this.font, Ascender = _b.Ascender, Descender = _b.Descender, FontBBox = _b.FontBBox; + var yTop = Ascender || FontBBox[3]; + var yBottom = Descender || FontBBox[1]; + var height = yTop - yBottom; + if (!descender) + height += Descender || 0; + return height / 1e3 * size; + }; + StandardFontEmbedder2.prototype.sizeOfFontAtHeight = function(height) { + var _a = this.font, Ascender = _a.Ascender, Descender = _a.Descender, FontBBox = _a.FontBBox; + var yTop = Ascender || FontBBox[3]; + var yBottom = Descender || FontBBox[1]; + return 1e3 * height / (yTop - yBottom); + }; + StandardFontEmbedder2.prototype.embedIntoContext = function(context, ref) { + var fontDict = context.obj({ + Type: "Font", + Subtype: "Type1", + BaseFont: this.customName || this.fontName, + Encoding: this.encoding === Encodings.WinAnsi ? "WinAnsiEncoding" : void 0 + }); + if (ref) { + context.assign(ref, fontDict); + return ref; + } else { + return context.register(fontDict); + } + }; + StandardFontEmbedder2.prototype.widthOfGlyph = function(glyphName) { + return this.font.getWidthOfGlyph(glyphName) || 250; + }; + StandardFontEmbedder2.prototype.encodeTextAsGlyphs = function(text) { + var codePoints = Array.from(text); + var glyphs = new Array(codePoints.length); + for (var idx = 0, len = codePoints.length; idx < len; idx++) { + var codePoint = toCodePoint(codePoints[idx]); + glyphs[idx] = this.encoding.encodeUnicodeCodePoint(codePoint); + } + return glyphs; + }; + StandardFontEmbedder2.for = function(fontName, customName) { + return new StandardFontEmbedder2(fontName, customName); + }; + return StandardFontEmbedder2; + }() +); +var StandardFontEmbedder_default = StandardFontEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/CMap.js +var createCmap = function(glyphs, glyphId) { + var bfChars = new Array(glyphs.length); + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + var glyph = glyphs[idx]; + var id = cmapHexFormat(cmapHexString(glyphId(glyph))); + var unicode = cmapHexFormat.apply(void 0, glyph.codePoints.map(cmapCodePointFormat)); + bfChars[idx] = [id, unicode]; + } + return fillCmapTemplate(bfChars); +}; +var fillCmapTemplate = function(bfChars) { + return "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo <<\n /Registry (Adobe)\n /Ordering (UCS)\n /Supplement 0\n>> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000>\nendcodespacerange\n" + bfChars.length + " beginbfchar\n" + bfChars.map(function(_a) { + var glyphId = _a[0], codePoint = _a[1]; + return glyphId + " " + codePoint; + }).join("\n") + "\nendbfchar\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend"; +}; +var cmapHexFormat = function() { + var values2 = []; + for (var _i = 0; _i < arguments.length; _i++) { + values2[_i] = arguments[_i]; + } + return "<" + values2.join("") + ">"; +}; +var cmapHexString = function(value) { + return toHexStringOfMinLength(value, 4); +}; +var cmapCodePointFormat = function(codePoint) { + if (isWithinBMP(codePoint)) + return cmapHexString(codePoint); + if (hasSurrogates(codePoint)) { + var hs = highSurrogate(codePoint); + var ls = lowSurrogate(codePoint); + return "" + cmapHexString(hs) + cmapHexString(ls); + } + var hex = toHexString(codePoint); + var msg = "0x" + hex + " is not a valid UTF-8 or UTF-16 codepoint."; + throw new Error(msg); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/FontFlags.js +var makeFontFlags = function(options) { + var flags = 0; + var flipBit = function(bit) { + flags |= 1 << bit - 1; + }; + if (options.fixedPitch) + flipBit(1); + if (options.serif) + flipBit(2); + if (options.symbolic) + flipBit(3); + if (options.script) + flipBit(4); + if (options.nonsymbolic) + flipBit(6); + if (options.italic) + flipBit(7); + if (options.allCap) + flipBit(17); + if (options.smallCap) + flipBit(18); + if (options.forceBold) + flipBit(19); + return flags; +}; +var deriveFontFlags = function(font) { + var familyClass = font["OS/2"] ? font["OS/2"].sFamilyClass : 0; + var flags = makeFontFlags({ + fixedPitch: font.post.isFixedPitch, + serif: 1 <= familyClass && familyClass <= 7, + symbolic: true, + script: familyClass === 10, + italic: font.head.macStyle.italic + }); + return flags; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/objects/PDFString.js +var PDFString = ( + /** @class */ + function(_super) { + __extends(PDFString2, _super); + function PDFString2(value) { + var _this = _super.call(this) || this; + _this.value = value; + return _this; + } + PDFString2.prototype.asBytes = function() { + var bytes = []; + var octal = ""; + var escaped = false; + var pushByte = function(byte2) { + if (byte2 !== void 0) + bytes.push(byte2); + escaped = false; + }; + for (var idx = 0, len = this.value.length; idx < len; idx++) { + var char = this.value[idx]; + var byte = toCharCode(char); + var nextChar = this.value[idx + 1]; + if (!escaped) { + if (byte === CharCodes_default.BackSlash) + escaped = true; + else + pushByte(byte); + } else { + if (byte === CharCodes_default.Newline) + pushByte(); + else if (byte === CharCodes_default.CarriageReturn) + pushByte(); + else if (byte === CharCodes_default.n) + pushByte(CharCodes_default.Newline); + else if (byte === CharCodes_default.r) + pushByte(CharCodes_default.CarriageReturn); + else if (byte === CharCodes_default.t) + pushByte(CharCodes_default.Tab); + else if (byte === CharCodes_default.b) + pushByte(CharCodes_default.Backspace); + else if (byte === CharCodes_default.f) + pushByte(CharCodes_default.FormFeed); + else if (byte === CharCodes_default.LeftParen) + pushByte(CharCodes_default.LeftParen); + else if (byte === CharCodes_default.RightParen) + pushByte(CharCodes_default.RightParen); + else if (byte === CharCodes_default.Backspace) + pushByte(CharCodes_default.BackSlash); + else if (byte >= CharCodes_default.Zero && byte <= CharCodes_default.Seven) { + octal += char; + if (octal.length === 3 || !(nextChar >= "0" && nextChar <= "7")) { + pushByte(parseInt(octal, 8)); + octal = ""; + } + } else { + pushByte(byte); + } + } + } + return new Uint8Array(bytes); + }; + PDFString2.prototype.decodeText = function() { + var bytes = this.asBytes(); + if (hasUtf16BOM(bytes)) + return utf16Decode(bytes); + return pdfDocEncodingDecode(bytes); + }; + PDFString2.prototype.decodeDate = function() { + var text = this.decodeText(); + var date = parseDate(text); + if (!date) + throw new InvalidPDFDateStringError(text); + return date; + }; + PDFString2.prototype.asString = function() { + return this.value; + }; + PDFString2.prototype.clone = function() { + return PDFString2.of(this.value); + }; + PDFString2.prototype.toString = function() { + return "(" + this.value + ")"; + }; + PDFString2.prototype.sizeInBytes = function() { + return this.value.length + 2; + }; + PDFString2.prototype.copyBytesInto = function(buffer, offset) { + buffer[offset++] = CharCodes_default.LeftParen; + offset += copyStringIntoBuffer(this.value, buffer, offset); + buffer[offset++] = CharCodes_default.RightParen; + return this.value.length + 2; + }; + PDFString2.of = function(value) { + return new PDFString2(value); + }; + PDFString2.fromDate = function(date) { + var year = padStart(String(date.getUTCFullYear()), 4, "0"); + var month = padStart(String(date.getUTCMonth() + 1), 2, "0"); + var day = padStart(String(date.getUTCDate()), 2, "0"); + var hours = padStart(String(date.getUTCHours()), 2, "0"); + var mins = padStart(String(date.getUTCMinutes()), 2, "0"); + var secs = padStart(String(date.getUTCSeconds()), 2, "0"); + return new PDFString2("D:" + year + month + day + hours + mins + secs + "Z"); + }; + return PDFString2; + }(PDFObject_default) +); +var PDFString_default = PDFString; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/CustomFontEmbedder.js +var CustomFontEmbedder = ( + /** @class */ + function() { + function CustomFontEmbedder2(font, fontData, customName, fontFeatures) { + var _this = this; + this.allGlyphsInFontSortedById = function() { + var glyphs = new Array(_this.font.characterSet.length); + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + var codePoint = _this.font.characterSet[idx]; + glyphs[idx] = _this.font.glyphForCodePoint(codePoint); + } + return sortedUniq(glyphs.sort(byAscendingId), function(g) { + return g.id; + }); + }; + this.font = font; + this.scale = 1e3 / this.font.unitsPerEm; + this.fontData = fontData; + this.fontName = this.font.postscriptName || "Font"; + this.customName = customName; + this.fontFeatures = fontFeatures; + this.baseFontName = ""; + this.glyphCache = Cache_default.populatedBy(this.allGlyphsInFontSortedById); + } + CustomFontEmbedder2.for = function(fontkit, fontData, customName, fontFeatures) { + return __awaiter(this, void 0, void 0, function() { + var font; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, fontkit.create(fontData)]; + case 1: + font = _a.sent(); + return [2, new CustomFontEmbedder2(font, fontData, customName, fontFeatures)]; + } + }); + }); + }; + CustomFontEmbedder2.prototype.encodeText = function(text) { + var glyphs = this.font.layout(text, this.fontFeatures).glyphs; + var hexCodes = new Array(glyphs.length); + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + hexCodes[idx] = toHexStringOfMinLength(glyphs[idx].id, 4); + } + return PDFHexString_default.of(hexCodes.join("")); + }; + CustomFontEmbedder2.prototype.widthOfTextAtSize = function(text, size) { + var glyphs = this.font.layout(text, this.fontFeatures).glyphs; + var totalWidth = 0; + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + totalWidth += glyphs[idx].advanceWidth * this.scale; + } + var scale2 = size / 1e3; + return totalWidth * scale2; + }; + CustomFontEmbedder2.prototype.heightOfFontAtSize = function(size, options) { + if (options === void 0) { + options = {}; + } + var _a = options.descender, descender = _a === void 0 ? true : _a; + var _b = this.font, ascent = _b.ascent, descent = _b.descent, bbox = _b.bbox; + var yTop = (ascent || bbox.maxY) * this.scale; + var yBottom = (descent || bbox.minY) * this.scale; + var height = yTop - yBottom; + if (!descender) + height -= Math.abs(descent) || 0; + return height / 1e3 * size; + }; + CustomFontEmbedder2.prototype.sizeOfFontAtHeight = function(height) { + var _a = this.font, ascent = _a.ascent, descent = _a.descent, bbox = _a.bbox; + var yTop = (ascent || bbox.maxY) * this.scale; + var yBottom = (descent || bbox.minY) * this.scale; + return 1e3 * height / (yTop - yBottom); + }; + CustomFontEmbedder2.prototype.embedIntoContext = function(context, ref) { + this.baseFontName = this.customName || context.addRandomSuffix(this.fontName); + return this.embedFontDict(context, ref); + }; + CustomFontEmbedder2.prototype.embedFontDict = function(context, ref) { + return __awaiter(this, void 0, void 0, function() { + var cidFontDictRef, unicodeCMapRef, fontDict; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, this.embedCIDFontDict(context)]; + case 1: + cidFontDictRef = _a.sent(); + unicodeCMapRef = this.embedUnicodeCmap(context); + fontDict = context.obj({ + Type: "Font", + Subtype: "Type0", + BaseFont: this.baseFontName, + Encoding: "Identity-H", + DescendantFonts: [cidFontDictRef], + ToUnicode: unicodeCMapRef + }); + if (ref) { + context.assign(ref, fontDict); + return [2, ref]; + } else { + return [2, context.register(fontDict)]; + } + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + CustomFontEmbedder2.prototype.isCFF = function() { + return this.font.cff; + }; + CustomFontEmbedder2.prototype.embedCIDFontDict = function(context) { + return __awaiter(this, void 0, void 0, function() { + var fontDescriptorRef, cidFontDict; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, this.embedFontDescriptor(context)]; + case 1: + fontDescriptorRef = _a.sent(); + cidFontDict = context.obj({ + Type: "Font", + Subtype: this.isCFF() ? "CIDFontType0" : "CIDFontType2", + CIDToGIDMap: "Identity", + BaseFont: this.baseFontName, + CIDSystemInfo: { + Registry: PDFString_default.of("Adobe"), + Ordering: PDFString_default.of("Identity"), + Supplement: 0 + }, + FontDescriptor: fontDescriptorRef, + W: this.computeWidths() + }); + return [2, context.register(cidFontDict)]; + } + }); + }); + }; + CustomFontEmbedder2.prototype.embedFontDescriptor = function(context) { + return __awaiter(this, void 0, void 0, function() { + var fontStreamRef, scale2, _a, italicAngle, ascent, descent, capHeight, xHeight, _b, minX, minY, maxX, maxY, fontDescriptor; + var _c; + return __generator(this, function(_d) { + switch (_d.label) { + case 0: + return [4, this.embedFontStream(context)]; + case 1: + fontStreamRef = _d.sent(); + scale2 = this.scale; + _a = this.font, italicAngle = _a.italicAngle, ascent = _a.ascent, descent = _a.descent, capHeight = _a.capHeight, xHeight = _a.xHeight; + _b = this.font.bbox, minX = _b.minX, minY = _b.minY, maxX = _b.maxX, maxY = _b.maxY; + fontDescriptor = context.obj((_c = { + Type: "FontDescriptor", + FontName: this.baseFontName, + Flags: deriveFontFlags(this.font), + FontBBox: [minX * scale2, minY * scale2, maxX * scale2, maxY * scale2], + ItalicAngle: italicAngle, + Ascent: ascent * scale2, + Descent: descent * scale2, + CapHeight: (capHeight || ascent) * scale2, + XHeight: (xHeight || 0) * scale2, + // Not sure how to compute/find this, nor is anybody else really: + // https://stackoverflow.com/questions/35485179/stemv-value-of-the-truetype-font + StemV: 0 + }, _c[this.isCFF() ? "FontFile3" : "FontFile2"] = fontStreamRef, _c)); + return [2, context.register(fontDescriptor)]; + } + }); + }); + }; + CustomFontEmbedder2.prototype.serializeFont = function() { + return __awaiter(this, void 0, void 0, function() { + return __generator(this, function(_a) { + return [2, this.fontData]; + }); + }); + }; + CustomFontEmbedder2.prototype.embedFontStream = function(context) { + return __awaiter(this, void 0, void 0, function() { + var fontStream, _a, _b; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + _b = (_a = context).flateStream; + return [4, this.serializeFont()]; + case 1: + fontStream = _b.apply(_a, [_c.sent(), { + Subtype: this.isCFF() ? "CIDFontType0C" : void 0 + }]); + return [2, context.register(fontStream)]; + } + }); + }); + }; + CustomFontEmbedder2.prototype.embedUnicodeCmap = function(context) { + var cmap = createCmap(this.glyphCache.access(), this.glyphId.bind(this)); + var cmapStream = context.flateStream(cmap); + return context.register(cmapStream); + }; + CustomFontEmbedder2.prototype.glyphId = function(glyph) { + return glyph ? glyph.id : -1; + }; + CustomFontEmbedder2.prototype.computeWidths = function() { + var glyphs = this.glyphCache.access(); + var widths = []; + var currSection = []; + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + var currGlyph = glyphs[idx]; + var prevGlyph = glyphs[idx - 1]; + var currGlyphId = this.glyphId(currGlyph); + var prevGlyphId = this.glyphId(prevGlyph); + if (idx === 0) { + widths.push(currGlyphId); + } else if (currGlyphId - prevGlyphId !== 1) { + widths.push(currSection); + widths.push(currGlyphId); + currSection = []; + } + currSection.push(currGlyph.advanceWidth * this.scale); + } + widths.push(currSection); + return widths; + }; + return CustomFontEmbedder2; + }() +); +var CustomFontEmbedder_default = CustomFontEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/CustomFontSubsetEmbedder.js +var CustomFontSubsetEmbedder = ( + /** @class */ + function(_super) { + __extends(CustomFontSubsetEmbedder2, _super); + function CustomFontSubsetEmbedder2(font, fontData, customFontName, fontFeatures) { + var _this = _super.call(this, font, fontData, customFontName, fontFeatures) || this; + _this.subset = _this.font.createSubset(); + _this.glyphs = []; + _this.glyphCache = Cache_default.populatedBy(function() { + return _this.glyphs; + }); + _this.glyphIdMap = /* @__PURE__ */ new Map(); + return _this; + } + CustomFontSubsetEmbedder2.for = function(fontkit, fontData, customFontName, fontFeatures) { + return __awaiter(this, void 0, void 0, function() { + var font; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, fontkit.create(fontData)]; + case 1: + font = _a.sent(); + return [2, new CustomFontSubsetEmbedder2(font, fontData, customFontName, fontFeatures)]; + } + }); + }); + }; + CustomFontSubsetEmbedder2.prototype.encodeText = function(text) { + var glyphs = this.font.layout(text, this.fontFeatures).glyphs; + var hexCodes = new Array(glyphs.length); + for (var idx = 0, len = glyphs.length; idx < len; idx++) { + var glyph = glyphs[idx]; + var subsetGlyphId = this.subset.includeGlyph(glyph); + this.glyphs[subsetGlyphId - 1] = glyph; + this.glyphIdMap.set(glyph.id, subsetGlyphId); + hexCodes[idx] = toHexStringOfMinLength(subsetGlyphId, 4); + } + this.glyphCache.invalidate(); + return PDFHexString_default.of(hexCodes.join("")); + }; + CustomFontSubsetEmbedder2.prototype.isCFF = function() { + return this.subset.cff; + }; + CustomFontSubsetEmbedder2.prototype.glyphId = function(glyph) { + return glyph ? this.glyphIdMap.get(glyph.id) : -1; + }; + CustomFontSubsetEmbedder2.prototype.serializeFont = function() { + var _this = this; + return new Promise(function(resolve, reject) { + var parts = []; + _this.subset.encodeStream().on("data", function(bytes) { + return parts.push(bytes); + }).on("end", function() { + return resolve(mergeUint8Arrays(parts)); + }).on("error", function(err) { + return reject(err); + }); + }); + }; + return CustomFontSubsetEmbedder2; + }(CustomFontEmbedder_default) +); +var CustomFontSubsetEmbedder_default = CustomFontSubsetEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/FileEmbedder.js +var AFRelationship; +(function(AFRelationship2) { + AFRelationship2["Source"] = "Source"; + AFRelationship2["Data"] = "Data"; + AFRelationship2["Alternative"] = "Alternative"; + AFRelationship2["Supplement"] = "Supplement"; + AFRelationship2["EncryptedPayload"] = "EncryptedPayload"; + AFRelationship2["FormData"] = "EncryptedPayload"; + AFRelationship2["Schema"] = "Schema"; + AFRelationship2["Unspecified"] = "Unspecified"; +})(AFRelationship || (AFRelationship = {})); +var FileEmbedder = ( + /** @class */ + function() { + function FileEmbedder2(fileData, fileName, options) { + if (options === void 0) { + options = {}; + } + this.fileData = fileData; + this.fileName = fileName; + this.options = options; + } + FileEmbedder2.for = function(bytes, fileName, options) { + if (options === void 0) { + options = {}; + } + return new FileEmbedder2(bytes, fileName, options); + }; + FileEmbedder2.prototype.embedIntoContext = function(context, ref) { + return __awaiter(this, void 0, void 0, function() { + var _a, mimeType, description, creationDate, modificationDate, afRelationship, embeddedFileStream, embeddedFileStreamRef, fileSpecDict; + return __generator(this, function(_b) { + _a = this.options, mimeType = _a.mimeType, description = _a.description, creationDate = _a.creationDate, modificationDate = _a.modificationDate, afRelationship = _a.afRelationship; + embeddedFileStream = context.flateStream(this.fileData, { + Type: "EmbeddedFile", + Subtype: mimeType !== null && mimeType !== void 0 ? mimeType : void 0, + Params: { + Size: this.fileData.length, + CreationDate: creationDate ? PDFString_default.fromDate(creationDate) : void 0, + ModDate: modificationDate ? PDFString_default.fromDate(modificationDate) : void 0 + } + }); + embeddedFileStreamRef = context.register(embeddedFileStream); + fileSpecDict = context.obj({ + Type: "Filespec", + F: PDFString_default.of(this.fileName), + UF: PDFHexString_default.fromText(this.fileName), + EF: { F: embeddedFileStreamRef }, + Desc: description ? PDFHexString_default.fromText(description) : void 0, + AFRelationship: afRelationship !== null && afRelationship !== void 0 ? afRelationship : void 0 + }); + if (ref) { + context.assign(ref, fileSpecDict); + return [2, ref]; + } else { + return [2, context.register(fileSpecDict)]; + } + return [ + 2 + /*return*/ + ]; + }); + }); + }; + return FileEmbedder2; + }() +); +var FileEmbedder_default = FileEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/JpegEmbedder.js +var MARKERS = [ + 65472, + 65473, + 65474, + 65475, + 65477, + 65478, + 65479, + 65480, + 65481, + 65482, + 65483, + 65484, + 65485, + 65486, + 65487 +]; +var ColorSpace; +(function(ColorSpace2) { + ColorSpace2["DeviceGray"] = "DeviceGray"; + ColorSpace2["DeviceRGB"] = "DeviceRGB"; + ColorSpace2["DeviceCMYK"] = "DeviceCMYK"; +})(ColorSpace || (ColorSpace = {})); +var ChannelToColorSpace = { + 1: ColorSpace.DeviceGray, + 3: ColorSpace.DeviceRGB, + 4: ColorSpace.DeviceCMYK +}; +var JpegEmbedder = ( + /** @class */ + function() { + function JpegEmbedder2(imageData, bitsPerComponent, width, height, colorSpace) { + this.imageData = imageData; + this.bitsPerComponent = bitsPerComponent; + this.width = width; + this.height = height; + this.colorSpace = colorSpace; + } + JpegEmbedder2.for = function(imageData) { + return __awaiter(this, void 0, void 0, function() { + var dataView, soi, pos, marker, bitsPerComponent, height, width, channelByte, channelName, colorSpace; + return __generator(this, function(_a) { + dataView = new DataView(imageData.buffer); + soi = dataView.getUint16(0); + if (soi !== 65496) + throw new Error("SOI not found in JPEG"); + pos = 2; + while (pos < dataView.byteLength) { + marker = dataView.getUint16(pos); + pos += 2; + if (MARKERS.includes(marker)) + break; + pos += dataView.getUint16(pos); + } + if (!MARKERS.includes(marker)) + throw new Error("Invalid JPEG"); + pos += 2; + bitsPerComponent = dataView.getUint8(pos++); + height = dataView.getUint16(pos); + pos += 2; + width = dataView.getUint16(pos); + pos += 2; + channelByte = dataView.getUint8(pos++); + channelName = ChannelToColorSpace[channelByte]; + if (!channelName) + throw new Error("Unknown JPEG channel."); + colorSpace = channelName; + return [2, new JpegEmbedder2(imageData, bitsPerComponent, width, height, colorSpace)]; + }); + }); + }; + JpegEmbedder2.prototype.embedIntoContext = function(context, ref) { + return __awaiter(this, void 0, void 0, function() { + var xObject; + return __generator(this, function(_a) { + xObject = context.stream(this.imageData, { + Type: "XObject", + Subtype: "Image", + BitsPerComponent: this.bitsPerComponent, + Width: this.width, + Height: this.height, + ColorSpace: this.colorSpace, + Filter: "DCTDecode", + // CMYK JPEG streams in PDF are typically stored complemented, + // with 1 as 'off' and 0 as 'on' (PDF 32000-1:2008, 8.6.4.4). + // + // Standalone CMYK JPEG (usually exported by Photoshop) are + // stored inverse, with 0 as 'off' and 1 as 'on', like RGB. + // + // Applying a swap here as a hedge that most bytes passing + // through this method will benefit from it. + Decode: this.colorSpace === ColorSpace.DeviceCMYK ? [1, 0, 1, 0, 1, 0, 1, 0] : void 0 + }); + if (ref) { + context.assign(ref, xObject); + return [2, ref]; + } else { + return [2, context.register(xObject)]; + } + return [ + 2 + /*return*/ + ]; + }); + }); + }; + return JpegEmbedder2; + }() +); +var JpegEmbedder_default = JpegEmbedder; + +// node_modules/.pnpm/@pdf-lib+upng@1.0.1/node_modules/@pdf-lib/upng/UPNG.js +var import_pako4 = __toESM(require_pako()); +var UPNG = {}; +UPNG.toRGBA8 = function(out) { + var w = out.width, h = out.height; + if (out.tabs.acTL == null) return [UPNG.toRGBA8.decodeImage(out.data, w, h, out).buffer]; + var frms = []; + if (out.frames[0].data == null) out.frames[0].data = out.data; + var len = w * h * 4, img = new Uint8Array(len), empty = new Uint8Array(len), prev = new Uint8Array(len); + for (var i = 0; i < out.frames.length; i++) { + var frm = out.frames[i]; + var fx = frm.rect.x, fy = frm.rect.y, fw = frm.rect.width, fh = frm.rect.height; + var fdata = UPNG.toRGBA8.decodeImage(frm.data, fw, fh, out); + if (i != 0) for (var j = 0; j < len; j++) prev[j] = img[j]; + if (frm.blend == 0) UPNG._copyTile(fdata, fw, fh, img, w, h, fx, fy, 0); + else if (frm.blend == 1) UPNG._copyTile(fdata, fw, fh, img, w, h, fx, fy, 1); + frms.push(img.buffer.slice(0)); + if (frm.dispose == 0) { + } else if (frm.dispose == 1) UPNG._copyTile(empty, fw, fh, img, w, h, fx, fy, 0); + else if (frm.dispose == 2) for (var j = 0; j < len; j++) img[j] = prev[j]; + } + return frms; +}; +UPNG.toRGBA8.decodeImage = function(data, w, h, out) { + var area = w * h, bpp = UPNG.decode._getBPP(out); + var bpl = Math.ceil(w * bpp / 8); + var bf = new Uint8Array(area * 4), bf32 = new Uint32Array(bf.buffer); + var ctype = out.ctype, depth = out.depth; + var rs = UPNG._bin.readUshort; + var time = Date.now(); + if (ctype == 6) { + var qarea = area << 2; + if (depth == 8) for (var i = 0; i < qarea; i += 4) { + bf[i] = data[i]; + bf[i + 1] = data[i + 1]; + bf[i + 2] = data[i + 2]; + bf[i + 3] = data[i + 3]; + } + if (depth == 16) for (var i = 0; i < qarea; i++) { + bf[i] = data[i << 1]; + } + } else if (ctype == 2) { + var ts = out.tabs["tRNS"]; + if (ts == null) { + if (depth == 8) for (var i = 0; i < area; i++) { + var ti = i * 3; + bf32[i] = 255 << 24 | data[ti + 2] << 16 | data[ti + 1] << 8 | data[ti]; + } + if (depth == 16) for (var i = 0; i < area; i++) { + var ti = i * 6; + bf32[i] = 255 << 24 | data[ti + 4] << 16 | data[ti + 2] << 8 | data[ti]; + } + } else { + var tr = ts[0], tg = ts[1], tb = ts[2]; + if (depth == 8) for (var i = 0; i < area; i++) { + var qi = i << 2, ti = i * 3; + bf32[i] = 255 << 24 | data[ti + 2] << 16 | data[ti + 1] << 8 | data[ti]; + if (data[ti] == tr && data[ti + 1] == tg && data[ti + 2] == tb) bf[qi + 3] = 0; + } + if (depth == 16) for (var i = 0; i < area; i++) { + var qi = i << 2, ti = i * 6; + bf32[i] = 255 << 24 | data[ti + 4] << 16 | data[ti + 2] << 8 | data[ti]; + if (rs(data, ti) == tr && rs(data, ti + 2) == tg && rs(data, ti + 4) == tb) bf[qi + 3] = 0; + } + } + } else if (ctype == 3) { + var p = out.tabs["PLTE"], ap = out.tabs["tRNS"], tl = ap ? ap.length : 0; + if (depth == 1) for (var y = 0; y < h; y++) { + var s0 = y * bpl, t0 = y * w; + for (var i = 0; i < w; i++) { + var qi = t0 + i << 2, j = data[s0 + (i >> 3)] >> 7 - ((i & 7) << 0) & 1, cj = 3 * j; + bf[qi] = p[cj]; + bf[qi + 1] = p[cj + 1]; + bf[qi + 2] = p[cj + 2]; + bf[qi + 3] = j < tl ? ap[j] : 255; + } + } + if (depth == 2) for (var y = 0; y < h; y++) { + var s0 = y * bpl, t0 = y * w; + for (var i = 0; i < w; i++) { + var qi = t0 + i << 2, j = data[s0 + (i >> 2)] >> 6 - ((i & 3) << 1) & 3, cj = 3 * j; + bf[qi] = p[cj]; + bf[qi + 1] = p[cj + 1]; + bf[qi + 2] = p[cj + 2]; + bf[qi + 3] = j < tl ? ap[j] : 255; + } + } + if (depth == 4) for (var y = 0; y < h; y++) { + var s0 = y * bpl, t0 = y * w; + for (var i = 0; i < w; i++) { + var qi = t0 + i << 2, j = data[s0 + (i >> 1)] >> 4 - ((i & 1) << 2) & 15, cj = 3 * j; + bf[qi] = p[cj]; + bf[qi + 1] = p[cj + 1]; + bf[qi + 2] = p[cj + 2]; + bf[qi + 3] = j < tl ? ap[j] : 255; + } + } + if (depth == 8) for (var i = 0; i < area; i++) { + var qi = i << 2, j = data[i], cj = 3 * j; + bf[qi] = p[cj]; + bf[qi + 1] = p[cj + 1]; + bf[qi + 2] = p[cj + 2]; + bf[qi + 3] = j < tl ? ap[j] : 255; + } + } else if (ctype == 4) { + if (depth == 8) for (var i = 0; i < area; i++) { + var qi = i << 2, di = i << 1, gr = data[di]; + bf[qi] = gr; + bf[qi + 1] = gr; + bf[qi + 2] = gr; + bf[qi + 3] = data[di + 1]; + } + if (depth == 16) for (var i = 0; i < area; i++) { + var qi = i << 2, di = i << 2, gr = data[di]; + bf[qi] = gr; + bf[qi + 1] = gr; + bf[qi + 2] = gr; + bf[qi + 3] = data[di + 2]; + } + } else if (ctype == 0) { + var tr = out.tabs["tRNS"] ? out.tabs["tRNS"] : -1; + for (var y = 0; y < h; y++) { + var off = y * bpl, to = y * w; + if (depth == 1) for (var x = 0; x < w; x++) { + var gr = 255 * (data[off + (x >>> 3)] >>> 7 - (x & 7) & 1), al = gr == tr * 255 ? 0 : 255; + bf32[to + x] = al << 24 | gr << 16 | gr << 8 | gr; + } + else if (depth == 2) for (var x = 0; x < w; x++) { + var gr = 85 * (data[off + (x >>> 2)] >>> 6 - ((x & 3) << 1) & 3), al = gr == tr * 85 ? 0 : 255; + bf32[to + x] = al << 24 | gr << 16 | gr << 8 | gr; + } + else if (depth == 4) for (var x = 0; x < w; x++) { + var gr = 17 * (data[off + (x >>> 1)] >>> 4 - ((x & 1) << 2) & 15), al = gr == tr * 17 ? 0 : 255; + bf32[to + x] = al << 24 | gr << 16 | gr << 8 | gr; + } + else if (depth == 8) for (var x = 0; x < w; x++) { + var gr = data[off + x], al = gr == tr ? 0 : 255; + bf32[to + x] = al << 24 | gr << 16 | gr << 8 | gr; + } + else if (depth == 16) for (var x = 0; x < w; x++) { + var gr = data[off + (x << 1)], al = rs(data, off + (x << i)) == tr ? 0 : 255; + bf32[to + x] = al << 24 | gr << 16 | gr << 8 | gr; + } + } + } + return bf; +}; +UPNG.decode = function(buff) { + var data = new Uint8Array(buff), offset = 8, bin = UPNG._bin, rUs = bin.readUshort, rUi = bin.readUint; + var out = { tabs: {}, frames: [] }; + var dd = new Uint8Array(data.length), doff = 0; + var fd, foff = 0; + var mgck = [137, 80, 78, 71, 13, 10, 26, 10]; + for (var i = 0; i < 8; i++) if (data[i] != mgck[i]) throw "The input is not a PNG file!"; + while (offset < data.length) { + var len = bin.readUint(data, offset); + offset += 4; + var type = bin.readASCII(data, offset, 4); + offset += 4; + if (type == "IHDR") { + UPNG.decode._IHDR(data, offset, out); + } else if (type == "IDAT") { + for (var i = 0; i < len; i++) dd[doff + i] = data[offset + i]; + doff += len; + } else if (type == "acTL") { + out.tabs[type] = { num_frames: rUi(data, offset), num_plays: rUi(data, offset + 4) }; + fd = new Uint8Array(data.length); + } else if (type == "fcTL") { + if (foff != 0) { + var fr = out.frames[out.frames.length - 1]; + fr.data = UPNG.decode._decompress(out, fd.slice(0, foff), fr.rect.width, fr.rect.height); + foff = 0; + } + var rct = { x: rUi(data, offset + 12), y: rUi(data, offset + 16), width: rUi(data, offset + 4), height: rUi(data, offset + 8) }; + var del = rUs(data, offset + 22); + del = rUs(data, offset + 20) / (del == 0 ? 100 : del); + var frm = { rect: rct, delay: Math.round(del * 1e3), dispose: data[offset + 24], blend: data[offset + 25] }; + out.frames.push(frm); + } else if (type == "fdAT") { + for (var i = 0; i < len - 4; i++) fd[foff + i] = data[offset + i + 4]; + foff += len - 4; + } else if (type == "pHYs") { + out.tabs[type] = [bin.readUint(data, offset), bin.readUint(data, offset + 4), data[offset + 8]]; + } else if (type == "cHRM") { + out.tabs[type] = []; + for (var i = 0; i < 8; i++) out.tabs[type].push(bin.readUint(data, offset + i * 4)); + } else if (type == "tEXt") { + if (out.tabs[type] == null) out.tabs[type] = {}; + var nz = bin.nextZero(data, offset); + var keyw = bin.readASCII(data, offset, nz - offset); + var text = bin.readASCII(data, nz + 1, offset + len - nz - 1); + out.tabs[type][keyw] = text; + } else if (type == "iTXt") { + if (out.tabs[type] == null) out.tabs[type] = {}; + var nz = 0, off = offset; + nz = bin.nextZero(data, off); + var keyw = bin.readASCII(data, off, nz - off); + off = nz + 1; + var cflag = data[off], cmeth = data[off + 1]; + off += 2; + nz = bin.nextZero(data, off); + var ltag = bin.readASCII(data, off, nz - off); + off = nz + 1; + nz = bin.nextZero(data, off); + var tkeyw = bin.readUTF8(data, off, nz - off); + off = nz + 1; + var text = bin.readUTF8(data, off, len - (off - offset)); + out.tabs[type][keyw] = text; + } else if (type == "PLTE") { + out.tabs[type] = bin.readBytes(data, offset, len); + } else if (type == "hIST") { + var pl = out.tabs["PLTE"].length / 3; + out.tabs[type] = []; + for (var i = 0; i < pl; i++) out.tabs[type].push(rUs(data, offset + i * 2)); + } else if (type == "tRNS") { + if (out.ctype == 3) out.tabs[type] = bin.readBytes(data, offset, len); + else if (out.ctype == 0) out.tabs[type] = rUs(data, offset); + else if (out.ctype == 2) out.tabs[type] = [rUs(data, offset), rUs(data, offset + 2), rUs(data, offset + 4)]; + } else if (type == "gAMA") out.tabs[type] = bin.readUint(data, offset) / 1e5; + else if (type == "sRGB") out.tabs[type] = data[offset]; + else if (type == "bKGD") { + if (out.ctype == 0 || out.ctype == 4) out.tabs[type] = [rUs(data, offset)]; + else if (out.ctype == 2 || out.ctype == 6) out.tabs[type] = [rUs(data, offset), rUs(data, offset + 2), rUs(data, offset + 4)]; + else if (out.ctype == 3) out.tabs[type] = data[offset]; + } else if (type == "IEND") { + break; + } + offset += len; + var crc = bin.readUint(data, offset); + offset += 4; + } + if (foff != 0) { + var fr = out.frames[out.frames.length - 1]; + fr.data = UPNG.decode._decompress(out, fd.slice(0, foff), fr.rect.width, fr.rect.height); + foff = 0; + } + out.data = UPNG.decode._decompress(out, dd, out.width, out.height); + delete out.compress; + delete out.interlace; + delete out.filter; + return out; +}; +UPNG.decode._decompress = function(out, dd, w, h) { + var time = Date.now(); + var bpp = UPNG.decode._getBPP(out), bpl = Math.ceil(w * bpp / 8), buff = new Uint8Array((bpl + 1 + out.interlace) * h); + dd = UPNG.decode._inflate(dd, buff); + var time = Date.now(); + if (out.interlace == 0) dd = UPNG.decode._filterZero(dd, out, 0, w, h); + else if (out.interlace == 1) dd = UPNG.decode._readInterlace(dd, out); + return dd; +}; +UPNG.decode._inflate = function(data, buff) { + var out = UPNG["inflateRaw"](new Uint8Array(data.buffer, 2, data.length - 6), buff); + return out; +}; +UPNG.inflateRaw = function() { + var H = {}; + H.H = {}; + H.H.N = function(N, W) { + var R = Uint8Array, i = 0, m = 0, J = 0, h = 0, Q = 0, X = 0, u = 0, w = 0, d = 0, v, C; + if (N[0] == 3 && N[1] == 0) return W ? W : new R(0); + var V = H.H, n = V.b, A = V.e, l = V.R, M = V.n, I = V.A, e = V.Z, b = V.m, Z = W == null; + if (Z) W = new R(N.length >>> 2 << 3); + while (i == 0) { + i = n(N, d, 1); + m = n(N, d + 1, 2); + d += 3; + if (m == 0) { + if ((d & 7) != 0) d += 8 - (d & 7); + var D = (d >>> 3) + 4, q = N[D - 4] | N[D - 3] << 8; + if (Z) W = H.H.W(W, w + q); + W.set(new R(N.buffer, N.byteOffset + D, q), w); + d = D + q << 3; + w += q; + continue; + } + if (Z) W = H.H.W(W, w + (1 << 17)); + if (m == 1) { + v = b.J; + C = b.h; + X = (1 << 9) - 1; + u = (1 << 5) - 1; + } + if (m == 2) { + J = A(N, d, 5) + 257; + h = A(N, d + 5, 5) + 1; + Q = A(N, d + 10, 4) + 4; + d += 14; + var E = d, j = 1; + for (var c = 0; c < 38; c += 2) { + b.Q[c] = 0; + b.Q[c + 1] = 0; + } + for (var c = 0; c < Q; c++) { + var K = A(N, d + c * 3, 3); + b.Q[(b.X[c] << 1) + 1] = K; + if (K > j) j = K; + } + d += 3 * Q; + M(b.Q, j); + I(b.Q, j, b.u); + v = b.w; + C = b.d; + d = l(b.u, (1 << j) - 1, J + h, N, d, b.v); + var r = V.V(b.v, 0, J, b.C); + X = (1 << r) - 1; + var S = V.V(b.v, J, h, b.D); + u = (1 << S) - 1; + M(b.C, r); + I(b.C, r, v); + M(b.D, S); + I(b.D, S, C); + } + while (true) { + var T = v[e(N, d) & X]; + d += T & 15; + var p = T >>> 4; + if (p >>> 8 == 0) { + W[w++] = p; + } else if (p == 256) { + break; + } else { + var z = w + p - 254; + if (p > 264) { + var _ = b.q[p - 257]; + z = w + (_ >>> 3) + A(N, d, _ & 7); + d += _ & 7; + } + var $ = C[e(N, d) & u]; + d += $ & 15; + var s = $ >>> 4, Y = b.c[s], a = (Y >>> 4) + n(N, d, Y & 15); + d += Y & 15; + while (w < z) { + W[w] = W[w++ - a]; + W[w] = W[w++ - a]; + W[w] = W[w++ - a]; + W[w] = W[w++ - a]; + } + w = z; + } + } + } + return W.length == w ? W : W.slice(0, w); + }; + H.H.W = function(N, W) { + var R = N.length; + if (W <= R) return N; + var V = new Uint8Array(R << 1); + V.set(N, 0); + return V; + }; + H.H.R = function(N, W, R, V, n, A) { + var l = H.H.e, M = H.H.Z, I = 0; + while (I < R) { + var e = N[M(V, n) & W]; + n += e & 15; + var b = e >>> 4; + if (b <= 15) { + A[I] = b; + I++; + } else { + var Z = 0, m = 0; + if (b == 16) { + m = 3 + l(V, n, 2); + n += 2; + Z = A[I - 1]; + } else if (b == 17) { + m = 3 + l(V, n, 3); + n += 3; + } else if (b == 18) { + m = 11 + l(V, n, 7); + n += 7; + } + var J = I + m; + while (I < J) { + A[I] = Z; + I++; + } + } + } + return n; + }; + H.H.V = function(N, W, R, V) { + var n = 0, A = 0, l = V.length >>> 1; + while (A < R) { + var M = N[A + W]; + V[A << 1] = 0; + V[(A << 1) + 1] = M; + if (M > n) n = M; + A++; + } + while (A < l) { + V[A << 1] = 0; + V[(A << 1) + 1] = 0; + A++; + } + return n; + }; + H.H.n = function(N, W) { + var R = H.H.m, V = N.length, n, A, l, M, I, e = R.j; + for (var M = 0; M <= W; M++) e[M] = 0; + for (M = 1; M < V; M += 2) e[N[M]]++; + var b = R.K; + n = 0; + e[0] = 0; + for (A = 1; A <= W; A++) { + n = n + e[A - 1] << 1; + b[A] = n; + } + for (l = 0; l < V; l += 2) { + I = N[l + 1]; + if (I != 0) { + N[l] = b[I]; + b[I]++; + } + } + }; + H.H.A = function(N, W, R) { + var V = N.length, n = H.H.m, A = n.r; + for (var l = 0; l < V; l += 2) if (N[l + 1] != 0) { + var M = l >> 1, I = N[l + 1], e = M << 4 | I, b = W - I, Z = N[l] << b, m = Z + (1 << b); + while (Z != m) { + var J = A[Z] >>> 15 - W; + R[J] = e; + Z++; + } + } + }; + H.H.l = function(N, W) { + var R = H.H.m.r, V = 15 - W; + for (var n = 0; n < N.length; n += 2) { + var A = N[n] << W - N[n + 1]; + N[n] = R[A] >>> V; + } + }; + H.H.M = function(N, W, R) { + R = R << (W & 7); + var V = W >>> 3; + N[V] |= R; + N[V + 1] |= R >>> 8; + }; + H.H.I = function(N, W, R) { + R = R << (W & 7); + var V = W >>> 3; + N[V] |= R; + N[V + 1] |= R >>> 8; + N[V + 2] |= R >>> 16; + }; + H.H.e = function(N, W, R) { + return (N[W >>> 3] | N[(W >>> 3) + 1] << 8) >>> (W & 7) & (1 << R) - 1; + }; + H.H.b = function(N, W, R) { + return (N[W >>> 3] | N[(W >>> 3) + 1] << 8 | N[(W >>> 3) + 2] << 16) >>> (W & 7) & (1 << R) - 1; + }; + H.H.Z = function(N, W) { + return (N[W >>> 3] | N[(W >>> 3) + 1] << 8 | N[(W >>> 3) + 2] << 16) >>> (W & 7); + }; + H.H.i = function(N, W) { + return (N[W >>> 3] | N[(W >>> 3) + 1] << 8 | N[(W >>> 3) + 2] << 16 | N[(W >>> 3) + 3] << 24) >>> (W & 7); + }; + H.H.m = function() { + var N = Uint16Array, W = Uint32Array; + return { K: new N(16), j: new N(16), X: [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15], S: [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 999, 999, 999], T: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0], q: new N(32), p: [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535], z: [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0], c: new W(32), J: new N(512), _: [], h: new N(32), $: [], w: new N(32768), C: [], v: [], d: new N(32768), D: [], u: new N(512), Q: [], r: new N(1 << 15), s: new W(286), Y: new W(30), a: new W(19), t: new W(15e3), k: new N(1 << 16), g: new N(1 << 15) }; + }(); + (function() { + var N = H.H.m, W = 1 << 15; + for (var R = 0; R < W; R++) { + var V = R; + V = (V & 2863311530) >>> 1 | (V & 1431655765) << 1; + V = (V & 3435973836) >>> 2 | (V & 858993459) << 2; + V = (V & 4042322160) >>> 4 | (V & 252645135) << 4; + V = (V & 4278255360) >>> 8 | (V & 16711935) << 8; + N.r[R] = (V >>> 16 | V << 16) >>> 17; + } + function n(A, l, M) { + while (l-- != 0) A.push(0, M); + } + for (var R = 0; R < 32; R++) { + N.q[R] = N.S[R] << 3 | N.T[R]; + N.c[R] = N.p[R] << 4 | N.z[R]; + } + n(N._, 144, 8); + n(N._, 255 - 143, 9); + n(N._, 279 - 255, 7); + n(N._, 287 - 279, 8); + H.H.n(N._, 9); + H.H.A(N._, 9, N.J); + H.H.l(N._, 9); + n(N.$, 32, 5); + H.H.n(N.$, 5); + H.H.A(N.$, 5, N.h); + H.H.l(N.$, 5); + n(N.Q, 19, 0); + n(N.C, 286, 0); + n(N.D, 30, 0); + n(N.v, 320, 0); + })(); + return H.H.N; +}(); +UPNG.decode._readInterlace = function(data, out) { + var w = out.width, h = out.height; + var bpp = UPNG.decode._getBPP(out), cbpp = bpp >> 3, bpl = Math.ceil(w * bpp / 8); + var img = new Uint8Array(h * bpl); + var di = 0; + var starting_row = [0, 0, 4, 0, 2, 0, 1]; + var starting_col = [0, 4, 0, 2, 0, 1, 0]; + var row_increment = [8, 8, 8, 4, 4, 2, 2]; + var col_increment = [8, 8, 4, 4, 2, 2, 1]; + var pass = 0; + while (pass < 7) { + var ri = row_increment[pass], ci = col_increment[pass]; + var sw = 0, sh = 0; + var cr = starting_row[pass]; + while (cr < h) { + cr += ri; + sh++; + } + var cc = starting_col[pass]; + while (cc < w) { + cc += ci; + sw++; + } + var bpll = Math.ceil(sw * bpp / 8); + UPNG.decode._filterZero(data, out, di, sw, sh); + var y = 0, row = starting_row[pass]; + while (row < h) { + var col = starting_col[pass]; + var cdi = di + y * bpll << 3; + while (col < w) { + if (bpp == 1) { + var val = data[cdi >> 3]; + val = val >> 7 - (cdi & 7) & 1; + img[row * bpl + (col >> 3)] |= val << 7 - ((col & 7) << 0); + } + if (bpp == 2) { + var val = data[cdi >> 3]; + val = val >> 6 - (cdi & 7) & 3; + img[row * bpl + (col >> 2)] |= val << 6 - ((col & 3) << 1); + } + if (bpp == 4) { + var val = data[cdi >> 3]; + val = val >> 4 - (cdi & 7) & 15; + img[row * bpl + (col >> 1)] |= val << 4 - ((col & 1) << 2); + } + if (bpp >= 8) { + var ii = row * bpl + col * cbpp; + for (var j = 0; j < cbpp; j++) img[ii + j] = data[(cdi >> 3) + j]; + } + cdi += bpp; + col += ci; + } + y++; + row += ri; + } + if (sw * sh != 0) di += sh * (1 + bpll); + pass = pass + 1; + } + return img; +}; +UPNG.decode._getBPP = function(out) { + var noc = [1, null, 3, 1, 2, null, 4][out.ctype]; + return noc * out.depth; +}; +UPNG.decode._filterZero = function(data, out, off, w, h) { + var bpp = UPNG.decode._getBPP(out), bpl = Math.ceil(w * bpp / 8), paeth = UPNG.decode._paeth; + bpp = Math.ceil(bpp / 8); + var i = 0, di = 1, type = data[off], x = 0; + if (type > 1) data[off] = [0, 0, 1][type - 2]; + if (type == 3) for (x = bpp; x < bpl; x++) data[x + 1] = data[x + 1] + (data[x + 1 - bpp] >>> 1) & 255; + for (var y = 0; y < h; y++) { + i = off + y * bpl; + di = i + y + 1; + type = data[di - 1]; + x = 0; + if (type == 0) for (; x < bpl; x++) data[i + x] = data[di + x]; + else if (type == 1) { + for (; x < bpp; x++) data[i + x] = data[di + x]; + for (; x < bpl; x++) data[i + x] = data[di + x] + data[i + x - bpp]; + } else if (type == 2) { + for (; x < bpl; x++) data[i + x] = data[di + x] + data[i + x - bpl]; + } else if (type == 3) { + for (; x < bpp; x++) data[i + x] = data[di + x] + (data[i + x - bpl] >>> 1); + for (; x < bpl; x++) data[i + x] = data[di + x] + (data[i + x - bpl] + data[i + x - bpp] >>> 1); + } else { + for (; x < bpp; x++) data[i + x] = data[di + x] + paeth(0, data[i + x - bpl], 0); + for (; x < bpl; x++) data[i + x] = data[di + x] + paeth(data[i + x - bpp], data[i + x - bpl], data[i + x - bpp - bpl]); + } + } + return data; +}; +UPNG.decode._paeth = function(a, b, c) { + var p = a + b - c, pa = p - a, pb = p - b, pc = p - c; + if (pa * pa <= pb * pb && pa * pa <= pc * pc) return a; + else if (pb * pb <= pc * pc) return b; + return c; +}; +UPNG.decode._IHDR = function(data, offset, out) { + var bin = UPNG._bin; + out.width = bin.readUint(data, offset); + offset += 4; + out.height = bin.readUint(data, offset); + offset += 4; + out.depth = data[offset]; + offset++; + out.ctype = data[offset]; + offset++; + out.compress = data[offset]; + offset++; + out.filter = data[offset]; + offset++; + out.interlace = data[offset]; + offset++; +}; +UPNG._bin = { + nextZero: function(data, p) { + while (data[p] != 0) p++; + return p; + }, + readUshort: function(buff, p) { + return buff[p] << 8 | buff[p + 1]; + }, + writeUshort: function(buff, p, n) { + buff[p] = n >> 8 & 255; + buff[p + 1] = n & 255; + }, + readUint: function(buff, p) { + return buff[p] * (256 * 256 * 256) + (buff[p + 1] << 16 | buff[p + 2] << 8 | buff[p + 3]); + }, + writeUint: function(buff, p, n) { + buff[p] = n >> 24 & 255; + buff[p + 1] = n >> 16 & 255; + buff[p + 2] = n >> 8 & 255; + buff[p + 3] = n & 255; + }, + readASCII: function(buff, p, l) { + var s = ""; + for (var i = 0; i < l; i++) s += String.fromCharCode(buff[p + i]); + return s; + }, + writeASCII: function(data, p, s) { + for (var i = 0; i < s.length; i++) data[p + i] = s.charCodeAt(i); + }, + readBytes: function(buff, p, l) { + var arr = []; + for (var i = 0; i < l; i++) arr.push(buff[p + i]); + return arr; + }, + pad: function(n) { + return n.length < 2 ? "0" + n : n; + }, + readUTF8: function(buff, p, l) { + var s = "", ns; + for (var i = 0; i < l; i++) s += "%" + UPNG._bin.pad(buff[p + i].toString(16)); + try { + ns = decodeURIComponent(s); + } catch (e) { + return UPNG._bin.readASCII(buff, p, l); + } + return ns; + } +}; +UPNG._copyTile = function(sb, sw, sh, tb, tw, th, xoff, yoff, mode) { + var w = Math.min(sw, tw), h = Math.min(sh, th); + var si = 0, ti = 0; + for (var y = 0; y < h; y++) + for (var x = 0; x < w; x++) { + if (xoff >= 0 && yoff >= 0) { + si = y * sw + x << 2; + ti = (yoff + y) * tw + xoff + x << 2; + } else { + si = (-yoff + y) * sw - xoff + x << 2; + ti = y * tw + x << 2; + } + if (mode == 0) { + tb[ti] = sb[si]; + tb[ti + 1] = sb[si + 1]; + tb[ti + 2] = sb[si + 2]; + tb[ti + 3] = sb[si + 3]; + } else if (mode == 1) { + var fa = sb[si + 3] * (1 / 255), fr = sb[si] * fa, fg = sb[si + 1] * fa, fb = sb[si + 2] * fa; + var ba = tb[ti + 3] * (1 / 255), br = tb[ti] * ba, bg = tb[ti + 1] * ba, bb = tb[ti + 2] * ba; + var ifa = 1 - fa, oa = fa + ba * ifa, ioa = oa == 0 ? 0 : 1 / oa; + tb[ti + 3] = 255 * oa; + tb[ti + 0] = (fr + br * ifa) * ioa; + tb[ti + 1] = (fg + bg * ifa) * ioa; + tb[ti + 2] = (fb + bb * ifa) * ioa; + } else if (mode == 2) { + var fa = sb[si + 3], fr = sb[si], fg = sb[si + 1], fb = sb[si + 2]; + var ba = tb[ti + 3], br = tb[ti], bg = tb[ti + 1], bb = tb[ti + 2]; + if (fa == ba && fr == br && fg == bg && fb == bb) { + tb[ti] = 0; + tb[ti + 1] = 0; + tb[ti + 2] = 0; + tb[ti + 3] = 0; + } else { + tb[ti] = fr; + tb[ti + 1] = fg; + tb[ti + 2] = fb; + tb[ti + 3] = fa; + } + } else if (mode == 3) { + var fa = sb[si + 3], fr = sb[si], fg = sb[si + 1], fb = sb[si + 2]; + var ba = tb[ti + 3], br = tb[ti], bg = tb[ti + 1], bb = tb[ti + 2]; + if (fa == ba && fr == br && fg == bg && fb == bb) continue; + if (fa < 220 && ba > 20) return false; + } + } + return true; +}; +UPNG.encode = function(bufs, w, h, ps, dels, tabs, forbidPlte) { + if (ps == null) ps = 0; + if (forbidPlte == null) forbidPlte = false; + var nimg = UPNG.encode.compress(bufs, w, h, ps, [false, false, false, 0, forbidPlte]); + UPNG.encode.compressPNG(nimg, -1); + return UPNG.encode._main(nimg, w, h, dels, tabs); +}; +UPNG.encodeLL = function(bufs, w, h, cc, ac, depth, dels, tabs) { + var nimg = { ctype: 0 + (cc == 1 ? 0 : 2) + (ac == 0 ? 0 : 4), depth, frames: [] }; + var time = Date.now(); + var bipp = (cc + ac) * depth, bipl = bipp * w; + for (var i = 0; i < bufs.length; i++) + nimg.frames.push({ rect: { x: 0, y: 0, width: w, height: h }, img: new Uint8Array(bufs[i]), blend: 0, dispose: 1, bpp: Math.ceil(bipp / 8), bpl: Math.ceil(bipl / 8) }); + UPNG.encode.compressPNG(nimg, 0, true); + var out = UPNG.encode._main(nimg, w, h, dels, tabs); + return out; +}; +UPNG.encode._main = function(nimg, w, h, dels, tabs) { + if (tabs == null) tabs = {}; + var crc = UPNG.crc.crc, wUi = UPNG._bin.writeUint, wUs = UPNG._bin.writeUshort, wAs = UPNG._bin.writeASCII; + var offset = 8, anim = nimg.frames.length > 1, pltAlpha = false; + var leng = 8 + (16 + 5 + 4) + (anim ? 20 : 0); + if (tabs["sRGB"] != null) leng += 8 + 1 + 4; + if (tabs["pHYs"] != null) leng += 8 + 9 + 4; + if (nimg.ctype == 3) { + var dl = nimg.plte.length; + for (var i = 0; i < dl; i++) if (nimg.plte[i] >>> 24 != 255) pltAlpha = true; + leng += 8 + dl * 3 + 4 + (pltAlpha ? 8 + dl * 1 + 4 : 0); + } + for (var j = 0; j < nimg.frames.length; j++) { + var fr = nimg.frames[j]; + if (anim) leng += 38; + leng += fr.cimg.length + 12; + if (j != 0) leng += 4; + } + leng += 12; + var data = new Uint8Array(leng); + var wr = [137, 80, 78, 71, 13, 10, 26, 10]; + for (var i = 0; i < 8; i++) data[i] = wr[i]; + wUi(data, offset, 13); + offset += 4; + wAs(data, offset, "IHDR"); + offset += 4; + wUi(data, offset, w); + offset += 4; + wUi(data, offset, h); + offset += 4; + data[offset] = nimg.depth; + offset++; + data[offset] = nimg.ctype; + offset++; + data[offset] = 0; + offset++; + data[offset] = 0; + offset++; + data[offset] = 0; + offset++; + wUi(data, offset, crc(data, offset - 17, 17)); + offset += 4; + if (tabs["sRGB"] != null) { + wUi(data, offset, 1); + offset += 4; + wAs(data, offset, "sRGB"); + offset += 4; + data[offset] = tabs["sRGB"]; + offset++; + wUi(data, offset, crc(data, offset - 5, 5)); + offset += 4; + } + if (tabs["pHYs"] != null) { + wUi(data, offset, 9); + offset += 4; + wAs(data, offset, "pHYs"); + offset += 4; + wUi(data, offset, tabs["pHYs"][0]); + offset += 4; + wUi(data, offset, tabs["pHYs"][1]); + offset += 4; + data[offset] = tabs["pHYs"][2]; + offset++; + wUi(data, offset, crc(data, offset - 13, 13)); + offset += 4; + } + if (anim) { + wUi(data, offset, 8); + offset += 4; + wAs(data, offset, "acTL"); + offset += 4; + wUi(data, offset, nimg.frames.length); + offset += 4; + wUi(data, offset, tabs["loop"] != null ? tabs["loop"] : 0); + offset += 4; + wUi(data, offset, crc(data, offset - 12, 12)); + offset += 4; + } + if (nimg.ctype == 3) { + var dl = nimg.plte.length; + wUi(data, offset, dl * 3); + offset += 4; + wAs(data, offset, "PLTE"); + offset += 4; + for (var i = 0; i < dl; i++) { + var ti = i * 3, c = nimg.plte[i], r = c & 255, g = c >>> 8 & 255, b = c >>> 16 & 255; + data[offset + ti + 0] = r; + data[offset + ti + 1] = g; + data[offset + ti + 2] = b; + } + offset += dl * 3; + wUi(data, offset, crc(data, offset - dl * 3 - 4, dl * 3 + 4)); + offset += 4; + if (pltAlpha) { + wUi(data, offset, dl); + offset += 4; + wAs(data, offset, "tRNS"); + offset += 4; + for (var i = 0; i < dl; i++) data[offset + i] = nimg.plte[i] >>> 24 & 255; + offset += dl; + wUi(data, offset, crc(data, offset - dl - 4, dl + 4)); + offset += 4; + } + } + var fi = 0; + for (var j = 0; j < nimg.frames.length; j++) { + var fr = nimg.frames[j]; + if (anim) { + wUi(data, offset, 26); + offset += 4; + wAs(data, offset, "fcTL"); + offset += 4; + wUi(data, offset, fi++); + offset += 4; + wUi(data, offset, fr.rect.width); + offset += 4; + wUi(data, offset, fr.rect.height); + offset += 4; + wUi(data, offset, fr.rect.x); + offset += 4; + wUi(data, offset, fr.rect.y); + offset += 4; + wUs(data, offset, dels[j]); + offset += 2; + wUs(data, offset, 1e3); + offset += 2; + data[offset] = fr.dispose; + offset++; + data[offset] = fr.blend; + offset++; + wUi(data, offset, crc(data, offset - 30, 30)); + offset += 4; + } + var imgd = fr.cimg, dl = imgd.length; + wUi(data, offset, dl + (j == 0 ? 0 : 4)); + offset += 4; + var ioff = offset; + wAs(data, offset, j == 0 ? "IDAT" : "fdAT"); + offset += 4; + if (j != 0) { + wUi(data, offset, fi++); + offset += 4; + } + data.set(imgd, offset); + offset += dl; + wUi(data, offset, crc(data, ioff, offset - ioff)); + offset += 4; + } + wUi(data, offset, 0); + offset += 4; + wAs(data, offset, "IEND"); + offset += 4; + wUi(data, offset, crc(data, offset - 4, 4)); + offset += 4; + return data.buffer; +}; +UPNG.encode.compressPNG = function(out, filter, levelZero) { + for (var i = 0; i < out.frames.length; i++) { + var frm = out.frames[i], nw = frm.rect.width, nh = frm.rect.height; + var fdata = new Uint8Array(nh * frm.bpl + nh); + frm.cimg = UPNG.encode._filterZero(frm.img, nh, frm.bpp, frm.bpl, fdata, filter, levelZero); + } +}; +UPNG.encode.compress = function(bufs, w, h, ps, prms) { + var onlyBlend = prms[0], evenCrd = prms[1], forbidPrev = prms[2], minBits = prms[3], forbidPlte = prms[4]; + var ctype = 6, depth = 8, alphaAnd = 255; + for (var j = 0; j < bufs.length; j++) { + var img = new Uint8Array(bufs[j]), ilen = img.length; + for (var i = 0; i < ilen; i += 4) alphaAnd &= img[i + 3]; + } + var gotAlpha = alphaAnd != 255; + var frms = UPNG.encode.framize(bufs, w, h, onlyBlend, evenCrd, forbidPrev); + var cmap = {}, plte = [], inds = []; + if (ps != 0) { + var nbufs = []; + for (var i = 0; i < frms.length; i++) nbufs.push(frms[i].img.buffer); + var abuf = UPNG.encode.concatRGBA(nbufs), qres = UPNG.quantize(abuf, ps); + var cof = 0, bb = new Uint8Array(qres.abuf); + for (var i = 0; i < frms.length; i++) { + var ti = frms[i].img, bln = ti.length; + inds.push(new Uint8Array(qres.inds.buffer, cof >> 2, bln >> 2)); + for (var j = 0; j < bln; j += 4) { + ti[j] = bb[cof + j]; + ti[j + 1] = bb[cof + j + 1]; + ti[j + 2] = bb[cof + j + 2]; + ti[j + 3] = bb[cof + j + 3]; + } + cof += bln; + } + for (var i = 0; i < qres.plte.length; i++) plte.push(qres.plte[i].est.rgba); + } else { + for (var j = 0; j < frms.length; j++) { + var frm = frms[j], img32 = new Uint32Array(frm.img.buffer), nw = frm.rect.width, ilen = img32.length; + var ind = new Uint8Array(ilen); + inds.push(ind); + for (var i = 0; i < ilen; i++) { + var c = img32[i]; + if (i != 0 && c == img32[i - 1]) ind[i] = ind[i - 1]; + else if (i > nw && c == img32[i - nw]) ind[i] = ind[i - nw]; + else { + var cmc = cmap[c]; + if (cmc == null) { + cmap[c] = cmc = plte.length; + plte.push(c); + if (plte.length >= 300) break; + } + ind[i] = cmc; + } + } + } + } + var cc = plte.length; + if (cc <= 256 && forbidPlte == false) { + if (cc <= 2) depth = 1; + else if (cc <= 4) depth = 2; + else if (cc <= 16) depth = 4; + else depth = 8; + depth = Math.max(depth, minBits); + } + for (var j = 0; j < frms.length; j++) { + var frm = frms[j], nx = frm.rect.x, ny = frm.rect.y, nw = frm.rect.width, nh = frm.rect.height; + var cimg = frm.img, cimg32 = new Uint32Array(cimg.buffer); + var bpl = 4 * nw, bpp = 4; + if (cc <= 256 && forbidPlte == false) { + bpl = Math.ceil(depth * nw / 8); + var nimg = new Uint8Array(bpl * nh); + var inj = inds[j]; + for (var y = 0; y < nh; y++) { + var i = y * bpl, ii = y * nw; + if (depth == 8) for (var x = 0; x < nw; x++) nimg[i + x] = inj[ii + x]; + else if (depth == 4) for (var x = 0; x < nw; x++) nimg[i + (x >> 1)] |= inj[ii + x] << 4 - (x & 1) * 4; + else if (depth == 2) for (var x = 0; x < nw; x++) nimg[i + (x >> 2)] |= inj[ii + x] << 6 - (x & 3) * 2; + else if (depth == 1) for (var x = 0; x < nw; x++) nimg[i + (x >> 3)] |= inj[ii + x] << 7 - (x & 7) * 1; + } + cimg = nimg; + ctype = 3; + bpp = 1; + } else if (gotAlpha == false && frms.length == 1) { + var nimg = new Uint8Array(nw * nh * 3), area = nw * nh; + for (var i = 0; i < area; i++) { + var ti = i * 3, qi = i * 4; + nimg[ti] = cimg[qi]; + nimg[ti + 1] = cimg[qi + 1]; + nimg[ti + 2] = cimg[qi + 2]; + } + cimg = nimg; + ctype = 2; + bpp = 3; + bpl = 3 * nw; + } + frm.img = cimg; + frm.bpl = bpl; + frm.bpp = bpp; + } + return { ctype, depth, plte, frames: frms }; +}; +UPNG.encode.framize = function(bufs, w, h, alwaysBlend, evenCrd, forbidPrev) { + var frms = []; + for (var j = 0; j < bufs.length; j++) { + var cimg = new Uint8Array(bufs[j]), cimg32 = new Uint32Array(cimg.buffer); + var nimg; + var nx = 0, ny = 0, nw = w, nh = h, blend = alwaysBlend ? 1 : 0; + if (j != 0) { + var tlim = forbidPrev || alwaysBlend || j == 1 || frms[j - 2].dispose != 0 ? 1 : 2, tstp = 0, tarea = 1e9; + for (var it = 0; it < tlim; it++) { + var pimg = new Uint8Array(bufs[j - 1 - it]), p32 = new Uint32Array(bufs[j - 1 - it]); + var mix = w, miy = h, max = -1, may = -1; + for (var y = 0; y < h; y++) for (var x = 0; x < w; x++) { + var i = y * w + x; + if (cimg32[i] != p32[i]) { + if (x < mix) mix = x; + if (x > max) max = x; + if (y < miy) miy = y; + if (y > may) may = y; + } + } + if (max == -1) mix = miy = max = may = 0; + if (evenCrd) { + if ((mix & 1) == 1) mix--; + if ((miy & 1) == 1) miy--; + } + var sarea = (max - mix + 1) * (may - miy + 1); + if (sarea < tarea) { + tarea = sarea; + tstp = it; + nx = mix; + ny = miy; + nw = max - mix + 1; + nh = may - miy + 1; + } + } + var pimg = new Uint8Array(bufs[j - 1 - tstp]); + if (tstp == 1) frms[j - 1].dispose = 2; + nimg = new Uint8Array(nw * nh * 4); + UPNG._copyTile(pimg, w, h, nimg, nw, nh, -nx, -ny, 0); + blend = UPNG._copyTile(cimg, w, h, nimg, nw, nh, -nx, -ny, 3) ? 1 : 0; + if (blend == 1) UPNG.encode._prepareDiff(cimg, w, h, nimg, { x: nx, y: ny, width: nw, height: nh }); + else UPNG._copyTile(cimg, w, h, nimg, nw, nh, -nx, -ny, 0); + } else nimg = cimg.slice(0); + frms.push({ rect: { x: nx, y: ny, width: nw, height: nh }, img: nimg, blend, dispose: 0 }); + } + if (alwaysBlend) for (var j = 0; j < frms.length; j++) { + var frm = frms[j]; + if (frm.blend == 1) continue; + var r0 = frm.rect, r1 = frms[j - 1].rect; + var miX = Math.min(r0.x, r1.x), miY = Math.min(r0.y, r1.y); + var maX = Math.max(r0.x + r0.width, r1.x + r1.width), maY = Math.max(r0.y + r0.height, r1.y + r1.height); + var r = { x: miX, y: miY, width: maX - miX, height: maY - miY }; + frms[j - 1].dispose = 1; + if (j - 1 != 0) + UPNG.encode._updateFrame(bufs, w, h, frms, j - 1, r, evenCrd); + UPNG.encode._updateFrame(bufs, w, h, frms, j, r, evenCrd); + } + var area = 0; + if (bufs.length != 1) for (var i = 0; i < frms.length; i++) { + var frm = frms[i]; + area += frm.rect.width * frm.rect.height; + } + return frms; +}; +UPNG.encode._updateFrame = function(bufs, w, h, frms, i, r, evenCrd) { + var U8 = Uint8Array, U32 = Uint32Array; + var pimg = new U8(bufs[i - 1]), pimg32 = new U32(bufs[i - 1]), nimg = i + 1 < bufs.length ? new U8(bufs[i + 1]) : null; + var cimg = new U8(bufs[i]), cimg32 = new U32(cimg.buffer); + var mix = w, miy = h, max = -1, may = -1; + for (var y = 0; y < r.height; y++) for (var x = 0; x < r.width; x++) { + var cx2 = r.x + x, cy2 = r.y + y; + var j = cy2 * w + cx2, cc = cimg32[j]; + if (cc == 0 || frms[i - 1].dispose == 0 && pimg32[j] == cc && (nimg == null || nimg[j * 4 + 3] != 0)) { + } else { + if (cx2 < mix) mix = cx2; + if (cx2 > max) max = cx2; + if (cy2 < miy) miy = cy2; + if (cy2 > may) may = cy2; + } + } + if (max == -1) mix = miy = max = may = 0; + if (evenCrd) { + if ((mix & 1) == 1) mix--; + if ((miy & 1) == 1) miy--; + } + r = { x: mix, y: miy, width: max - mix + 1, height: may - miy + 1 }; + var fr = frms[i]; + fr.rect = r; + fr.blend = 1; + fr.img = new Uint8Array(r.width * r.height * 4); + if (frms[i - 1].dispose == 0) { + UPNG._copyTile(pimg, w, h, fr.img, r.width, r.height, -r.x, -r.y, 0); + UPNG.encode._prepareDiff(cimg, w, h, fr.img, r); + } else + UPNG._copyTile(cimg, w, h, fr.img, r.width, r.height, -r.x, -r.y, 0); +}; +UPNG.encode._prepareDiff = function(cimg, w, h, nimg, rec) { + UPNG._copyTile(cimg, w, h, nimg, rec.width, rec.height, -rec.x, -rec.y, 2); +}; +UPNG.encode._filterZero = function(img, h, bpp, bpl, data, filter, levelZero) { + var fls = [], ftry = [0, 1, 2, 3, 4]; + if (filter != -1) ftry = [filter]; + else if (h * bpl > 5e5 || bpp == 1) ftry = [0]; + var opts; + if (levelZero) opts = { level: 0 }; + var CMPR = levelZero && UZIP != null ? UZIP : import_pako4.default; + for (var i = 0; i < ftry.length; i++) { + for (var y = 0; y < h; y++) UPNG.encode._filterLine(data, img, y, bpl, bpp, ftry[i]); + fls.push(CMPR["deflate"](data, opts)); + } + var ti, tsize = 1e9; + for (var i = 0; i < fls.length; i++) if (fls[i].length < tsize) { + ti = i; + tsize = fls[i].length; + } + return fls[ti]; +}; +UPNG.encode._filterLine = function(data, img, y, bpl, bpp, type) { + var i = y * bpl, di = i + y, paeth = UPNG.decode._paeth; + data[di] = type; + di++; + if (type == 0) { + if (bpl < 500) for (var x = 0; x < bpl; x++) data[di + x] = img[i + x]; + else data.set(new Uint8Array(img.buffer, i, bpl), di); + } else if (type == 1) { + for (var x = 0; x < bpp; x++) data[di + x] = img[i + x]; + for (var x = bpp; x < bpl; x++) data[di + x] = img[i + x] - img[i + x - bpp] + 256 & 255; + } else if (y == 0) { + for (var x = 0; x < bpp; x++) data[di + x] = img[i + x]; + if (type == 2) for (var x = bpp; x < bpl; x++) data[di + x] = img[i + x]; + if (type == 3) for (var x = bpp; x < bpl; x++) data[di + x] = img[i + x] - (img[i + x - bpp] >> 1) + 256 & 255; + if (type == 4) for (var x = bpp; x < bpl; x++) data[di + x] = img[i + x] - paeth(img[i + x - bpp], 0, 0) + 256 & 255; + } else { + if (type == 2) { + for (var x = 0; x < bpl; x++) data[di + x] = img[i + x] + 256 - img[i + x - bpl] & 255; + } + if (type == 3) { + for (var x = 0; x < bpp; x++) data[di + x] = img[i + x] + 256 - (img[i + x - bpl] >> 1) & 255; + for (var x = bpp; x < bpl; x++) data[di + x] = img[i + x] + 256 - (img[i + x - bpl] + img[i + x - bpp] >> 1) & 255; + } + if (type == 4) { + for (var x = 0; x < bpp; x++) data[di + x] = img[i + x] + 256 - paeth(0, img[i + x - bpl], 0) & 255; + for (var x = bpp; x < bpl; x++) data[di + x] = img[i + x] + 256 - paeth(img[i + x - bpp], img[i + x - bpl], img[i + x - bpp - bpl]) & 255; + } + } +}; +UPNG.crc = { + table: function() { + var tab = new Uint32Array(256); + for (var n = 0; n < 256; n++) { + var c = n; + for (var k = 0; k < 8; k++) { + if (c & 1) c = 3988292384 ^ c >>> 1; + else c = c >>> 1; + } + tab[n] = c; + } + return tab; + }(), + update: function(c, buf, off, len) { + for (var i = 0; i < len; i++) c = UPNG.crc.table[(c ^ buf[off + i]) & 255] ^ c >>> 8; + return c; + }, + crc: function(b, o, l) { + return UPNG.crc.update(4294967295, b, o, l) ^ 4294967295; + } +}; +UPNG.quantize = function(abuf, ps) { + var oimg = new Uint8Array(abuf), nimg = oimg.slice(0), nimg32 = new Uint32Array(nimg.buffer); + var KD = UPNG.quantize.getKDtree(nimg, ps); + var root = KD[0], leafs = KD[1]; + var planeDst = UPNG.quantize.planeDst; + var sb = oimg, tb = nimg32, len = sb.length; + var inds = new Uint8Array(oimg.length >> 2); + for (var i = 0; i < len; i += 4) { + var r = sb[i] * (1 / 255), g = sb[i + 1] * (1 / 255), b = sb[i + 2] * (1 / 255), a = sb[i + 3] * (1 / 255); + var nd = UPNG.quantize.getNearest(root, r, g, b, a); + inds[i >> 2] = nd.ind; + tb[i >> 2] = nd.est.rgba; + } + return { abuf: nimg.buffer, inds, plte: leafs }; +}; +UPNG.quantize.getKDtree = function(nimg, ps, err) { + if (err == null) err = 1e-4; + var nimg32 = new Uint32Array(nimg.buffer); + var root = { i0: 0, i1: nimg.length, bst: null, est: null, tdst: 0, left: null, right: null }; + root.bst = UPNG.quantize.stats(nimg, root.i0, root.i1); + root.est = UPNG.quantize.estats(root.bst); + var leafs = [root]; + while (leafs.length < ps) { + var maxL = 0, mi = 0; + for (var i = 0; i < leafs.length; i++) if (leafs[i].est.L > maxL) { + maxL = leafs[i].est.L; + mi = i; + } + if (maxL < err) break; + var node = leafs[mi]; + var s0 = UPNG.quantize.splitPixels(nimg, nimg32, node.i0, node.i1, node.est.e, node.est.eMq255); + var s0wrong = node.i0 >= s0 || node.i1 <= s0; + if (s0wrong) { + node.est.L = 0; + continue; + } + var ln = { i0: node.i0, i1: s0, bst: null, est: null, tdst: 0, left: null, right: null }; + ln.bst = UPNG.quantize.stats(nimg, ln.i0, ln.i1); + ln.est = UPNG.quantize.estats(ln.bst); + var rn = { i0: s0, i1: node.i1, bst: null, est: null, tdst: 0, left: null, right: null }; + rn.bst = { R: [], m: [], N: node.bst.N - ln.bst.N }; + for (var i = 0; i < 16; i++) rn.bst.R[i] = node.bst.R[i] - ln.bst.R[i]; + for (var i = 0; i < 4; i++) rn.bst.m[i] = node.bst.m[i] - ln.bst.m[i]; + rn.est = UPNG.quantize.estats(rn.bst); + node.left = ln; + node.right = rn; + leafs[mi] = ln; + leafs.push(rn); + } + leafs.sort(function(a, b) { + return b.bst.N - a.bst.N; + }); + for (var i = 0; i < leafs.length; i++) leafs[i].ind = i; + return [root, leafs]; +}; +UPNG.quantize.getNearest = function(nd, r, g, b, a) { + if (nd.left == null) { + nd.tdst = UPNG.quantize.dist(nd.est.q, r, g, b, a); + return nd; + } + var planeDst = UPNG.quantize.planeDst(nd.est, r, g, b, a); + var node0 = nd.left, node1 = nd.right; + if (planeDst > 0) { + node0 = nd.right; + node1 = nd.left; + } + var ln = UPNG.quantize.getNearest(node0, r, g, b, a); + if (ln.tdst <= planeDst * planeDst) return ln; + var rn = UPNG.quantize.getNearest(node1, r, g, b, a); + return rn.tdst < ln.tdst ? rn : ln; +}; +UPNG.quantize.planeDst = function(est, r, g, b, a) { + var e = est.e; + return e[0] * r + e[1] * g + e[2] * b + e[3] * a - est.eMq; +}; +UPNG.quantize.dist = function(q, r, g, b, a) { + var d0 = r - q[0], d1 = g - q[1], d2 = b - q[2], d3 = a - q[3]; + return d0 * d0 + d1 * d1 + d2 * d2 + d3 * d3; +}; +UPNG.quantize.splitPixels = function(nimg, nimg32, i0, i1, e, eMq) { + var vecDot = UPNG.quantize.vecDot; + i1 -= 4; + var shfs = 0; + while (i0 < i1) { + while (vecDot(nimg, i0, e) <= eMq) i0 += 4; + while (vecDot(nimg, i1, e) > eMq) i1 -= 4; + if (i0 >= i1) break; + var t = nimg32[i0 >> 2]; + nimg32[i0 >> 2] = nimg32[i1 >> 2]; + nimg32[i1 >> 2] = t; + i0 += 4; + i1 -= 4; + } + while (vecDot(nimg, i0, e) > eMq) i0 -= 4; + return i0 + 4; +}; +UPNG.quantize.vecDot = function(nimg, i, e) { + return nimg[i] * e[0] + nimg[i + 1] * e[1] + nimg[i + 2] * e[2] + nimg[i + 3] * e[3]; +}; +UPNG.quantize.stats = function(nimg, i0, i1) { + var R = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + var m = [0, 0, 0, 0]; + var N = i1 - i0 >> 2; + for (var i = i0; i < i1; i += 4) { + var r = nimg[i] * (1 / 255), g = nimg[i + 1] * (1 / 255), b = nimg[i + 2] * (1 / 255), a = nimg[i + 3] * (1 / 255); + m[0] += r; + m[1] += g; + m[2] += b; + m[3] += a; + R[0] += r * r; + R[1] += r * g; + R[2] += r * b; + R[3] += r * a; + R[5] += g * g; + R[6] += g * b; + R[7] += g * a; + R[10] += b * b; + R[11] += b * a; + R[15] += a * a; + } + R[4] = R[1]; + R[8] = R[2]; + R[9] = R[6]; + R[12] = R[3]; + R[13] = R[7]; + R[14] = R[11]; + return { R, m, N }; +}; +UPNG.quantize.estats = function(stats) { + var R = stats.R, m = stats.m, N = stats.N; + var m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], iN = N == 0 ? 0 : 1 / N; + var Rj = [ + R[0] - m0 * m0 * iN, + R[1] - m0 * m1 * iN, + R[2] - m0 * m2 * iN, + R[3] - m0 * m3 * iN, + R[4] - m1 * m0 * iN, + R[5] - m1 * m1 * iN, + R[6] - m1 * m2 * iN, + R[7] - m1 * m3 * iN, + R[8] - m2 * m0 * iN, + R[9] - m2 * m1 * iN, + R[10] - m2 * m2 * iN, + R[11] - m2 * m3 * iN, + R[12] - m3 * m0 * iN, + R[13] - m3 * m1 * iN, + R[14] - m3 * m2 * iN, + R[15] - m3 * m3 * iN + ]; + var A = Rj, M = UPNG.M4; + var b = [0.5, 0.5, 0.5, 0.5], mi = 0, tmi = 0; + if (N != 0) + for (var i = 0; i < 10; i++) { + b = M.multVec(A, b); + tmi = Math.sqrt(M.dot(b, b)); + b = M.sml(1 / tmi, b); + if (Math.abs(tmi - mi) < 1e-9) break; + mi = tmi; + } + var q = [m0 * iN, m1 * iN, m2 * iN, m3 * iN]; + var eMq255 = M.dot(M.sml(255, q), b); + return { + Cov: Rj, + q, + e: b, + L: mi, + eMq255, + eMq: M.dot(b, q), + rgba: (Math.round(255 * q[3]) << 24 | Math.round(255 * q[2]) << 16 | Math.round(255 * q[1]) << 8 | Math.round(255 * q[0]) << 0) >>> 0 + }; +}; +UPNG.M4 = { + multVec: function(m, v) { + return [ + m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3] * v[3], + m[4] * v[0] + m[5] * v[1] + m[6] * v[2] + m[7] * v[3], + m[8] * v[0] + m[9] * v[1] + m[10] * v[2] + m[11] * v[3], + m[12] * v[0] + m[13] * v[1] + m[14] * v[2] + m[15] * v[3] + ]; + }, + dot: function(x, y) { + return x[0] * y[0] + x[1] * y[1] + x[2] * y[2] + x[3] * y[3]; + }, + sml: function(a, y) { + return [a * y[0], a * y[1], a * y[2], a * y[3]]; + } +}; +UPNG.encode.concatRGBA = function(bufs) { + var tlen = 0; + for (var i = 0; i < bufs.length; i++) tlen += bufs[i].byteLength; + var nimg = new Uint8Array(tlen), noff = 0; + for (var i = 0; i < bufs.length; i++) { + var img = new Uint8Array(bufs[i]), il = img.length; + for (var j = 0; j < il; j += 4) { + var r = img[j], g = img[j + 1], b = img[j + 2], a = img[j + 3]; + if (a == 0) r = g = b = 0; + nimg[noff + j] = r; + nimg[noff + j + 1] = g; + nimg[noff + j + 2] = b; + nimg[noff + j + 3] = a; + } + noff += il; + } + return nimg.buffer; +}; +var UPNG_default = UPNG; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/utils/png.js +var getImageType = function(ctype) { + if (ctype === 0) + return PngType.Greyscale; + if (ctype === 2) + return PngType.Truecolour; + if (ctype === 3) + return PngType.IndexedColour; + if (ctype === 4) + return PngType.GreyscaleWithAlpha; + if (ctype === 6) + return PngType.TruecolourWithAlpha; + throw new Error("Unknown color type: " + ctype); +}; +var splitAlphaChannel = function(rgbaChannel) { + var pixelCount = Math.floor(rgbaChannel.length / 4); + var rgbChannel = new Uint8Array(pixelCount * 3); + var alphaChannel = new Uint8Array(pixelCount * 1); + var rgbaOffset = 0; + var rgbOffset = 0; + var alphaOffset = 0; + while (rgbaOffset < rgbaChannel.length) { + rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++]; + rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++]; + rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++]; + alphaChannel[alphaOffset++] = rgbaChannel[rgbaOffset++]; + } + return { rgbChannel, alphaChannel }; +}; +var PngType; +(function(PngType2) { + PngType2["Greyscale"] = "Greyscale"; + PngType2["Truecolour"] = "Truecolour"; + PngType2["IndexedColour"] = "IndexedColour"; + PngType2["GreyscaleWithAlpha"] = "GreyscaleWithAlpha"; + PngType2["TruecolourWithAlpha"] = "TruecolourWithAlpha"; +})(PngType || (PngType = {})); +var PNG = ( + /** @class */ + function() { + function PNG2(pngData) { + var upng = UPNG_default.decode(pngData); + var frames = UPNG_default.toRGBA8(upng); + if (frames.length > 1) + throw new Error("Animated PNGs are not supported"); + var frame = new Uint8Array(frames[0]); + var _a = splitAlphaChannel(frame), rgbChannel = _a.rgbChannel, alphaChannel = _a.alphaChannel; + this.rgbChannel = rgbChannel; + var hasAlphaValues = alphaChannel.some(function(a) { + return a < 255; + }); + if (hasAlphaValues) + this.alphaChannel = alphaChannel; + this.type = getImageType(upng.ctype); + this.width = upng.width; + this.height = upng.height; + this.bitsPerComponent = 8; + } + PNG2.load = function(pngData) { + return new PNG2(pngData); + }; + return PNG2; + }() +); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/PngEmbedder.js +var PngEmbedder = ( + /** @class */ + function() { + function PngEmbedder2(png) { + this.image = png; + this.bitsPerComponent = png.bitsPerComponent; + this.width = png.width; + this.height = png.height; + this.colorSpace = "DeviceRGB"; + } + PngEmbedder2.for = function(imageData) { + return __awaiter(this, void 0, void 0, function() { + var png; + return __generator(this, function(_a) { + png = PNG.load(imageData); + return [2, new PngEmbedder2(png)]; + }); + }); + }; + PngEmbedder2.prototype.embedIntoContext = function(context, ref) { + return __awaiter(this, void 0, void 0, function() { + var SMask, xObject; + return __generator(this, function(_a) { + SMask = this.embedAlphaChannel(context); + xObject = context.flateStream(this.image.rgbChannel, { + Type: "XObject", + Subtype: "Image", + BitsPerComponent: this.image.bitsPerComponent, + Width: this.image.width, + Height: this.image.height, + ColorSpace: this.colorSpace, + SMask + }); + if (ref) { + context.assign(ref, xObject); + return [2, ref]; + } else { + return [2, context.register(xObject)]; + } + return [ + 2 + /*return*/ + ]; + }); + }); + }; + PngEmbedder2.prototype.embedAlphaChannel = function(context) { + if (!this.image.alphaChannel) + return void 0; + var xObject = context.flateStream(this.image.alphaChannel, { + Type: "XObject", + Subtype: "Image", + Height: this.image.height, + Width: this.image.width, + BitsPerComponent: this.image.bitsPerComponent, + ColorSpace: "DeviceGray", + Decode: [0, 1] + }); + return context.register(xObject); + }; + return PngEmbedder2; + }() +); +var PngEmbedder_default = PngEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/Stream.js +var Stream = ( + /** @class */ + function() { + function Stream2(buffer, start, length) { + this.bytes = buffer; + this.start = start || 0; + this.pos = this.start; + this.end = !!start && !!length ? start + length : this.bytes.length; + } + Object.defineProperty(Stream2.prototype, "length", { + get: function() { + return this.end - this.start; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Stream2.prototype, "isEmpty", { + get: function() { + return this.length === 0; + }, + enumerable: false, + configurable: true + }); + Stream2.prototype.getByte = function() { + if (this.pos >= this.end) { + return -1; + } + return this.bytes[this.pos++]; + }; + Stream2.prototype.getUint16 = function() { + var b0 = this.getByte(); + var b1 = this.getByte(); + if (b0 === -1 || b1 === -1) { + return -1; + } + return (b0 << 8) + b1; + }; + Stream2.prototype.getInt32 = function() { + var b0 = this.getByte(); + var b1 = this.getByte(); + var b2 = this.getByte(); + var b3 = this.getByte(); + return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; + }; + Stream2.prototype.getBytes = function(length, forceClamped) { + if (forceClamped === void 0) { + forceClamped = false; + } + var bytes = this.bytes; + var pos = this.pos; + var strEnd = this.end; + if (!length) { + var subarray = bytes.subarray(pos, strEnd); + return forceClamped ? new Uint8ClampedArray(subarray) : subarray; + } else { + var end = pos + length; + if (end > strEnd) { + end = strEnd; + } + this.pos = end; + var subarray = bytes.subarray(pos, end); + return forceClamped ? new Uint8ClampedArray(subarray) : subarray; + } + }; + Stream2.prototype.peekByte = function() { + var peekedByte = this.getByte(); + this.pos--; + return peekedByte; + }; + Stream2.prototype.peekBytes = function(length, forceClamped) { + if (forceClamped === void 0) { + forceClamped = false; + } + var bytes = this.getBytes(length, forceClamped); + this.pos -= bytes.length; + return bytes; + }; + Stream2.prototype.skip = function(n) { + if (!n) { + n = 1; + } + this.pos += n; + }; + Stream2.prototype.reset = function() { + this.pos = this.start; + }; + Stream2.prototype.moveStart = function() { + this.start = this.pos; + }; + Stream2.prototype.makeSubStream = function(start, length) { + return new Stream2(this.bytes, start, length); + }; + Stream2.prototype.decode = function() { + return this.bytes; + }; + return Stream2; + }() +); +var Stream_default = Stream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/DecodeStream.js +var emptyBuffer = new Uint8Array(0); +var DecodeStream = ( + /** @class */ + function() { + function DecodeStream2(maybeMinBufferLength) { + this.pos = 0; + this.bufferLength = 0; + this.eof = false; + this.buffer = emptyBuffer; + this.minBufferLength = 512; + if (maybeMinBufferLength) { + while (this.minBufferLength < maybeMinBufferLength) { + this.minBufferLength *= 2; + } + } + } + Object.defineProperty(DecodeStream2.prototype, "isEmpty", { + get: function() { + while (!this.eof && this.bufferLength === 0) { + this.readBlock(); + } + return this.bufferLength === 0; + }, + enumerable: false, + configurable: true + }); + DecodeStream2.prototype.getByte = function() { + var pos = this.pos; + while (this.bufferLength <= pos) { + if (this.eof) { + return -1; + } + this.readBlock(); + } + return this.buffer[this.pos++]; + }; + DecodeStream2.prototype.getUint16 = function() { + var b0 = this.getByte(); + var b1 = this.getByte(); + if (b0 === -1 || b1 === -1) { + return -1; + } + return (b0 << 8) + b1; + }; + DecodeStream2.prototype.getInt32 = function() { + var b0 = this.getByte(); + var b1 = this.getByte(); + var b2 = this.getByte(); + var b3 = this.getByte(); + return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; + }; + DecodeStream2.prototype.getBytes = function(length, forceClamped) { + if (forceClamped === void 0) { + forceClamped = false; + } + var end; + var pos = this.pos; + if (length) { + this.ensureBuffer(pos + length); + end = pos + length; + while (!this.eof && this.bufferLength < end) { + this.readBlock(); + } + var bufEnd = this.bufferLength; + if (end > bufEnd) { + end = bufEnd; + } + } else { + while (!this.eof) { + this.readBlock(); + } + end = this.bufferLength; + } + this.pos = end; + var subarray = this.buffer.subarray(pos, end); + return forceClamped && !(subarray instanceof Uint8ClampedArray) ? new Uint8ClampedArray(subarray) : subarray; + }; + DecodeStream2.prototype.peekByte = function() { + var peekedByte = this.getByte(); + this.pos--; + return peekedByte; + }; + DecodeStream2.prototype.peekBytes = function(length, forceClamped) { + if (forceClamped === void 0) { + forceClamped = false; + } + var bytes = this.getBytes(length, forceClamped); + this.pos -= bytes.length; + return bytes; + }; + DecodeStream2.prototype.skip = function(n) { + if (!n) { + n = 1; + } + this.pos += n; + }; + DecodeStream2.prototype.reset = function() { + this.pos = 0; + }; + DecodeStream2.prototype.makeSubStream = function(start, length) { + var end = start + length; + while (this.bufferLength <= end && !this.eof) { + this.readBlock(); + } + return new Stream_default( + this.buffer, + start, + length + /* dict */ + ); + }; + DecodeStream2.prototype.decode = function() { + while (!this.eof) + this.readBlock(); + return this.buffer.subarray(0, this.bufferLength); + }; + DecodeStream2.prototype.readBlock = function() { + throw new MethodNotImplementedError(this.constructor.name, "readBlock"); + }; + DecodeStream2.prototype.ensureBuffer = function(requested) { + var buffer = this.buffer; + if (requested <= buffer.byteLength) { + return buffer; + } + var size = this.minBufferLength; + while (size < requested) { + size *= 2; + } + var buffer2 = new Uint8Array(size); + buffer2.set(buffer); + return this.buffer = buffer2; + }; + return DecodeStream2; + }() +); +var DecodeStream_default = DecodeStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/Ascii85Stream.js +var isSpace = function(ch) { + return ch === 32 || ch === 9 || ch === 13 || ch === 10; +}; +var Ascii85Stream = ( + /** @class */ + function(_super) { + __extends(Ascii85Stream2, _super); + function Ascii85Stream2(stream2, maybeLength) { + var _this = _super.call(this, maybeLength) || this; + _this.stream = stream2; + _this.input = new Uint8Array(5); + if (maybeLength) { + maybeLength = 0.8 * maybeLength; + } + return _this; + } + Ascii85Stream2.prototype.readBlock = function() { + var TILDA_CHAR = 126; + var Z_LOWER_CHAR = 122; + var EOF = -1; + var stream2 = this.stream; + var c = stream2.getByte(); + while (isSpace(c)) { + c = stream2.getByte(); + } + if (c === EOF || c === TILDA_CHAR) { + this.eof = true; + return; + } + var bufferLength = this.bufferLength; + var buffer; + var i; + if (c === Z_LOWER_CHAR) { + buffer = this.ensureBuffer(bufferLength + 4); + for (i = 0; i < 4; ++i) { + buffer[bufferLength + i] = 0; + } + this.bufferLength += 4; + } else { + var input = this.input; + input[0] = c; + for (i = 1; i < 5; ++i) { + c = stream2.getByte(); + while (isSpace(c)) { + c = stream2.getByte(); + } + input[i] = c; + if (c === EOF || c === TILDA_CHAR) { + break; + } + } + buffer = this.ensureBuffer(bufferLength + i - 1); + this.bufferLength += i - 1; + if (i < 5) { + for (; i < 5; ++i) { + input[i] = 33 + 84; + } + this.eof = true; + } + var t = 0; + for (i = 0; i < 5; ++i) { + t = t * 85 + (input[i] - 33); + } + for (i = 3; i >= 0; --i) { + buffer[bufferLength + i] = t & 255; + t >>= 8; + } + } + }; + return Ascii85Stream2; + }(DecodeStream_default) +); +var Ascii85Stream_default = Ascii85Stream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/AsciiHexStream.js +var AsciiHexStream = ( + /** @class */ + function(_super) { + __extends(AsciiHexStream2, _super); + function AsciiHexStream2(stream2, maybeLength) { + var _this = _super.call(this, maybeLength) || this; + _this.stream = stream2; + _this.firstDigit = -1; + if (maybeLength) { + maybeLength = 0.5 * maybeLength; + } + return _this; + } + AsciiHexStream2.prototype.readBlock = function() { + var UPSTREAM_BLOCK_SIZE = 8e3; + var bytes = this.stream.getBytes(UPSTREAM_BLOCK_SIZE); + if (!bytes.length) { + this.eof = true; + return; + } + var maxDecodeLength = bytes.length + 1 >> 1; + var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength); + var bufferLength = this.bufferLength; + var firstDigit = this.firstDigit; + for (var i = 0, ii = bytes.length; i < ii; i++) { + var ch = bytes[i]; + var digit = void 0; + if (ch >= 48 && ch <= 57) { + digit = ch & 15; + } else if (ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102) { + digit = (ch & 15) + 9; + } else if (ch === 62) { + this.eof = true; + break; + } else { + continue; + } + if (firstDigit < 0) { + firstDigit = digit; + } else { + buffer[bufferLength++] = firstDigit << 4 | digit; + firstDigit = -1; + } + } + if (firstDigit >= 0 && this.eof) { + buffer[bufferLength++] = firstDigit << 4; + firstDigit = -1; + } + this.firstDigit = firstDigit; + this.bufferLength = bufferLength; + }; + return AsciiHexStream2; + }(DecodeStream_default) +); +var AsciiHexStream_default = AsciiHexStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/FlateStream.js +var codeLenCodeMap = new Int32Array([ + 16, + 17, + 18, + 0, + 8, + 7, + 9, + 6, + 10, + 5, + 11, + 4, + 12, + 3, + 13, + 2, + 14, + 1, + 15 +]); +var lengthDecode = new Int32Array([ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 65547, + 65549, + 65551, + 65553, + 131091, + 131095, + 131099, + 131103, + 196643, + 196651, + 196659, + 196667, + 262211, + 262227, + 262243, + 262259, + 327811, + 327843, + 327875, + 327907, + 258, + 258, + 258 +]); +var distDecode = new Int32Array([ + 1, + 2, + 3, + 4, + 65541, + 65543, + 131081, + 131085, + 196625, + 196633, + 262177, + 262193, + 327745, + 327777, + 393345, + 393409, + 459009, + 459137, + 524801, + 525057, + 590849, + 591361, + 657409, + 658433, + 724993, + 727041, + 794625, + 798721, + 868353, + 876545 +]); +var fixedLitCodeTab = [new Int32Array([ + 459008, + 524368, + 524304, + 524568, + 459024, + 524400, + 524336, + 590016, + 459016, + 524384, + 524320, + 589984, + 524288, + 524416, + 524352, + 590048, + 459012, + 524376, + 524312, + 589968, + 459028, + 524408, + 524344, + 590032, + 459020, + 524392, + 524328, + 59e4, + 524296, + 524424, + 524360, + 590064, + 459010, + 524372, + 524308, + 524572, + 459026, + 524404, + 524340, + 590024, + 459018, + 524388, + 524324, + 589992, + 524292, + 524420, + 524356, + 590056, + 459014, + 524380, + 524316, + 589976, + 459030, + 524412, + 524348, + 590040, + 459022, + 524396, + 524332, + 590008, + 524300, + 524428, + 524364, + 590072, + 459009, + 524370, + 524306, + 524570, + 459025, + 524402, + 524338, + 590020, + 459017, + 524386, + 524322, + 589988, + 524290, + 524418, + 524354, + 590052, + 459013, + 524378, + 524314, + 589972, + 459029, + 524410, + 524346, + 590036, + 459021, + 524394, + 524330, + 590004, + 524298, + 524426, + 524362, + 590068, + 459011, + 524374, + 524310, + 524574, + 459027, + 524406, + 524342, + 590028, + 459019, + 524390, + 524326, + 589996, + 524294, + 524422, + 524358, + 590060, + 459015, + 524382, + 524318, + 589980, + 459031, + 524414, + 524350, + 590044, + 459023, + 524398, + 524334, + 590012, + 524302, + 524430, + 524366, + 590076, + 459008, + 524369, + 524305, + 524569, + 459024, + 524401, + 524337, + 590018, + 459016, + 524385, + 524321, + 589986, + 524289, + 524417, + 524353, + 590050, + 459012, + 524377, + 524313, + 589970, + 459028, + 524409, + 524345, + 590034, + 459020, + 524393, + 524329, + 590002, + 524297, + 524425, + 524361, + 590066, + 459010, + 524373, + 524309, + 524573, + 459026, + 524405, + 524341, + 590026, + 459018, + 524389, + 524325, + 589994, + 524293, + 524421, + 524357, + 590058, + 459014, + 524381, + 524317, + 589978, + 459030, + 524413, + 524349, + 590042, + 459022, + 524397, + 524333, + 590010, + 524301, + 524429, + 524365, + 590074, + 459009, + 524371, + 524307, + 524571, + 459025, + 524403, + 524339, + 590022, + 459017, + 524387, + 524323, + 589990, + 524291, + 524419, + 524355, + 590054, + 459013, + 524379, + 524315, + 589974, + 459029, + 524411, + 524347, + 590038, + 459021, + 524395, + 524331, + 590006, + 524299, + 524427, + 524363, + 590070, + 459011, + 524375, + 524311, + 524575, + 459027, + 524407, + 524343, + 590030, + 459019, + 524391, + 524327, + 589998, + 524295, + 524423, + 524359, + 590062, + 459015, + 524383, + 524319, + 589982, + 459031, + 524415, + 524351, + 590046, + 459023, + 524399, + 524335, + 590014, + 524303, + 524431, + 524367, + 590078, + 459008, + 524368, + 524304, + 524568, + 459024, + 524400, + 524336, + 590017, + 459016, + 524384, + 524320, + 589985, + 524288, + 524416, + 524352, + 590049, + 459012, + 524376, + 524312, + 589969, + 459028, + 524408, + 524344, + 590033, + 459020, + 524392, + 524328, + 590001, + 524296, + 524424, + 524360, + 590065, + 459010, + 524372, + 524308, + 524572, + 459026, + 524404, + 524340, + 590025, + 459018, + 524388, + 524324, + 589993, + 524292, + 524420, + 524356, + 590057, + 459014, + 524380, + 524316, + 589977, + 459030, + 524412, + 524348, + 590041, + 459022, + 524396, + 524332, + 590009, + 524300, + 524428, + 524364, + 590073, + 459009, + 524370, + 524306, + 524570, + 459025, + 524402, + 524338, + 590021, + 459017, + 524386, + 524322, + 589989, + 524290, + 524418, + 524354, + 590053, + 459013, + 524378, + 524314, + 589973, + 459029, + 524410, + 524346, + 590037, + 459021, + 524394, + 524330, + 590005, + 524298, + 524426, + 524362, + 590069, + 459011, + 524374, + 524310, + 524574, + 459027, + 524406, + 524342, + 590029, + 459019, + 524390, + 524326, + 589997, + 524294, + 524422, + 524358, + 590061, + 459015, + 524382, + 524318, + 589981, + 459031, + 524414, + 524350, + 590045, + 459023, + 524398, + 524334, + 590013, + 524302, + 524430, + 524366, + 590077, + 459008, + 524369, + 524305, + 524569, + 459024, + 524401, + 524337, + 590019, + 459016, + 524385, + 524321, + 589987, + 524289, + 524417, + 524353, + 590051, + 459012, + 524377, + 524313, + 589971, + 459028, + 524409, + 524345, + 590035, + 459020, + 524393, + 524329, + 590003, + 524297, + 524425, + 524361, + 590067, + 459010, + 524373, + 524309, + 524573, + 459026, + 524405, + 524341, + 590027, + 459018, + 524389, + 524325, + 589995, + 524293, + 524421, + 524357, + 590059, + 459014, + 524381, + 524317, + 589979, + 459030, + 524413, + 524349, + 590043, + 459022, + 524397, + 524333, + 590011, + 524301, + 524429, + 524365, + 590075, + 459009, + 524371, + 524307, + 524571, + 459025, + 524403, + 524339, + 590023, + 459017, + 524387, + 524323, + 589991, + 524291, + 524419, + 524355, + 590055, + 459013, + 524379, + 524315, + 589975, + 459029, + 524411, + 524347, + 590039, + 459021, + 524395, + 524331, + 590007, + 524299, + 524427, + 524363, + 590071, + 459011, + 524375, + 524311, + 524575, + 459027, + 524407, + 524343, + 590031, + 459019, + 524391, + 524327, + 589999, + 524295, + 524423, + 524359, + 590063, + 459015, + 524383, + 524319, + 589983, + 459031, + 524415, + 524351, + 590047, + 459023, + 524399, + 524335, + 590015, + 524303, + 524431, + 524367, + 590079 +]), 9]; +var fixedDistCodeTab = [new Int32Array([ + 327680, + 327696, + 327688, + 327704, + 327684, + 327700, + 327692, + 327708, + 327682, + 327698, + 327690, + 327706, + 327686, + 327702, + 327694, + 0, + 327681, + 327697, + 327689, + 327705, + 327685, + 327701, + 327693, + 327709, + 327683, + 327699, + 327691, + 327707, + 327687, + 327703, + 327695, + 0 +]), 5]; +var FlateStream = ( + /** @class */ + function(_super) { + __extends(FlateStream2, _super); + function FlateStream2(stream2, maybeLength) { + var _this = _super.call(this, maybeLength) || this; + _this.stream = stream2; + var cmf = stream2.getByte(); + var flg = stream2.getByte(); + if (cmf === -1 || flg === -1) { + throw new Error("Invalid header in flate stream: " + cmf + ", " + flg); + } + if ((cmf & 15) !== 8) { + throw new Error("Unknown compression method in flate stream: " + cmf + ", " + flg); + } + if (((cmf << 8) + flg) % 31 !== 0) { + throw new Error("Bad FCHECK in flate stream: " + cmf + ", " + flg); + } + if (flg & 32) { + throw new Error("FDICT bit set in flate stream: " + cmf + ", " + flg); + } + _this.codeSize = 0; + _this.codeBuf = 0; + return _this; + } + FlateStream2.prototype.readBlock = function() { + var buffer; + var len; + var str = this.stream; + var hdr = this.getBits(3); + if (hdr & 1) { + this.eof = true; + } + hdr >>= 1; + if (hdr === 0) { + var b = void 0; + if ((b = str.getByte()) === -1) { + throw new Error("Bad block header in flate stream"); + } + var blockLen = b; + if ((b = str.getByte()) === -1) { + throw new Error("Bad block header in flate stream"); + } + blockLen |= b << 8; + if ((b = str.getByte()) === -1) { + throw new Error("Bad block header in flate stream"); + } + var check = b; + if ((b = str.getByte()) === -1) { + throw new Error("Bad block header in flate stream"); + } + check |= b << 8; + if (check !== (~blockLen & 65535) && (blockLen !== 0 || check !== 0)) { + throw new Error("Bad uncompressed block length in flate stream"); + } + this.codeBuf = 0; + this.codeSize = 0; + var bufferLength = this.bufferLength; + buffer = this.ensureBuffer(bufferLength + blockLen); + var end = bufferLength + blockLen; + this.bufferLength = end; + if (blockLen === 0) { + if (str.peekByte() === -1) { + this.eof = true; + } + } else { + for (var n = bufferLength; n < end; ++n) { + if ((b = str.getByte()) === -1) { + this.eof = true; + break; + } + buffer[n] = b; + } + } + return; + } + var litCodeTable; + var distCodeTable; + if (hdr === 1) { + litCodeTable = fixedLitCodeTab; + distCodeTable = fixedDistCodeTab; + } else if (hdr === 2) { + var numLitCodes = this.getBits(5) + 257; + var numDistCodes = this.getBits(5) + 1; + var numCodeLenCodes = this.getBits(4) + 4; + var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length); + var i = void 0; + for (i = 0; i < numCodeLenCodes; ++i) { + codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3); + } + var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths); + len = 0; + i = 0; + var codes = numLitCodes + numDistCodes; + var codeLengths = new Uint8Array(codes); + var bitsLength = void 0; + var bitsOffset = void 0; + var what = void 0; + while (i < codes) { + var code = this.getCode(codeLenCodeTab); + if (code === 16) { + bitsLength = 2; + bitsOffset = 3; + what = len; + } else if (code === 17) { + bitsLength = 3; + bitsOffset = 3; + what = len = 0; + } else if (code === 18) { + bitsLength = 7; + bitsOffset = 11; + what = len = 0; + } else { + codeLengths[i++] = len = code; + continue; + } + var repeatLength = this.getBits(bitsLength) + bitsOffset; + while (repeatLength-- > 0) { + codeLengths[i++] = what; + } + } + litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes)); + distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes)); + } else { + throw new Error("Unknown block type in flate stream"); + } + buffer = this.buffer; + var limit = buffer ? buffer.length : 0; + var pos = this.bufferLength; + while (true) { + var code1 = this.getCode(litCodeTable); + if (code1 < 256) { + if (pos + 1 >= limit) { + buffer = this.ensureBuffer(pos + 1); + limit = buffer.length; + } + buffer[pos++] = code1; + continue; + } + if (code1 === 256) { + this.bufferLength = pos; + return; + } + code1 -= 257; + code1 = lengthDecode[code1]; + var code2 = code1 >> 16; + if (code2 > 0) { + code2 = this.getBits(code2); + } + len = (code1 & 65535) + code2; + code1 = this.getCode(distCodeTable); + code1 = distDecode[code1]; + code2 = code1 >> 16; + if (code2 > 0) { + code2 = this.getBits(code2); + } + var dist = (code1 & 65535) + code2; + if (pos + len >= limit) { + buffer = this.ensureBuffer(pos + len); + limit = buffer.length; + } + for (var k = 0; k < len; ++k, ++pos) { + buffer[pos] = buffer[pos - dist]; + } + } + }; + FlateStream2.prototype.getBits = function(bits) { + var str = this.stream; + var codeSize = this.codeSize; + var codeBuf = this.codeBuf; + var b; + while (codeSize < bits) { + if ((b = str.getByte()) === -1) { + throw new Error("Bad encoding in flate stream"); + } + codeBuf |= b << codeSize; + codeSize += 8; + } + b = codeBuf & (1 << bits) - 1; + this.codeBuf = codeBuf >> bits; + this.codeSize = codeSize -= bits; + return b; + }; + FlateStream2.prototype.getCode = function(table) { + var str = this.stream; + var codes = table[0]; + var maxLen = table[1]; + var codeSize = this.codeSize; + var codeBuf = this.codeBuf; + var b; + while (codeSize < maxLen) { + if ((b = str.getByte()) === -1) { + break; + } + codeBuf |= b << codeSize; + codeSize += 8; + } + var code = codes[codeBuf & (1 << maxLen) - 1]; + if (typeof codes === "number") { + console.log("FLATE:", code); + } + var codeLen = code >> 16; + var codeVal = code & 65535; + if (codeLen < 1 || codeSize < codeLen) { + throw new Error("Bad encoding in flate stream"); + } + this.codeBuf = codeBuf >> codeLen; + this.codeSize = codeSize - codeLen; + return codeVal; + }; + FlateStream2.prototype.generateHuffmanTable = function(lengths) { + var n = lengths.length; + var maxLen = 0; + var i; + for (i = 0; i < n; ++i) { + if (lengths[i] > maxLen) { + maxLen = lengths[i]; + } + } + var size = 1 << maxLen; + var codes = new Int32Array(size); + for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) { + for (var val = 0; val < n; ++val) { + if (lengths[val] === len) { + var code2 = 0; + var t = code; + for (i = 0; i < len; ++i) { + code2 = code2 << 1 | t & 1; + t >>= 1; + } + for (i = code2; i < size; i += skip) { + codes[i] = len << 16 | val; + } + ++code; + } + } + } + return [codes, maxLen]; + }; + return FlateStream2; + }(DecodeStream_default) +); +var FlateStream_default = FlateStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/LZWStream.js +var LZWStream = ( + /** @class */ + function(_super) { + __extends(LZWStream2, _super); + function LZWStream2(stream2, maybeLength, earlyChange) { + var _this = _super.call(this, maybeLength) || this; + _this.stream = stream2; + _this.cachedData = 0; + _this.bitsCached = 0; + var maxLzwDictionarySize = 4096; + var lzwState = { + earlyChange, + codeLength: 9, + nextCode: 258, + dictionaryValues: new Uint8Array(maxLzwDictionarySize), + dictionaryLengths: new Uint16Array(maxLzwDictionarySize), + dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize), + currentSequence: new Uint8Array(maxLzwDictionarySize), + currentSequenceLength: 0 + }; + for (var i = 0; i < 256; ++i) { + lzwState.dictionaryValues[i] = i; + lzwState.dictionaryLengths[i] = 1; + } + _this.lzwState = lzwState; + return _this; + } + LZWStream2.prototype.readBlock = function() { + var blockSize = 512; + var estimatedDecodedSize = blockSize * 2; + var decodedSizeDelta = blockSize; + var i; + var j; + var q; + var lzwState = this.lzwState; + if (!lzwState) { + return; + } + var earlyChange = lzwState.earlyChange; + var nextCode = lzwState.nextCode; + var dictionaryValues = lzwState.dictionaryValues; + var dictionaryLengths = lzwState.dictionaryLengths; + var dictionaryPrevCodes = lzwState.dictionaryPrevCodes; + var codeLength = lzwState.codeLength; + var prevCode = lzwState.prevCode; + var currentSequence = lzwState.currentSequence; + var currentSequenceLength = lzwState.currentSequenceLength; + var decodedLength = 0; + var currentBufferLength = this.bufferLength; + var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize); + for (i = 0; i < blockSize; i++) { + var code = this.readBits(codeLength); + var hasPrev = currentSequenceLength > 0; + if (!code || code < 256) { + currentSequence[0] = code; + currentSequenceLength = 1; + } else if (code >= 258) { + if (code < nextCode) { + currentSequenceLength = dictionaryLengths[code]; + for (j = currentSequenceLength - 1, q = code; j >= 0; j--) { + currentSequence[j] = dictionaryValues[q]; + q = dictionaryPrevCodes[q]; + } + } else { + currentSequence[currentSequenceLength++] = currentSequence[0]; + } + } else if (code === 256) { + codeLength = 9; + nextCode = 258; + currentSequenceLength = 0; + continue; + } else { + this.eof = true; + delete this.lzwState; + break; + } + if (hasPrev) { + dictionaryPrevCodes[nextCode] = prevCode; + dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1; + dictionaryValues[nextCode] = currentSequence[0]; + nextCode++; + codeLength = nextCode + earlyChange & nextCode + earlyChange - 1 ? codeLength : Math.min(Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1, 12) | 0; + } + prevCode = code; + decodedLength += currentSequenceLength; + if (estimatedDecodedSize < decodedLength) { + do { + estimatedDecodedSize += decodedSizeDelta; + } while (estimatedDecodedSize < decodedLength); + buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize); + } + for (j = 0; j < currentSequenceLength; j++) { + buffer[currentBufferLength++] = currentSequence[j]; + } + } + lzwState.nextCode = nextCode; + lzwState.codeLength = codeLength; + lzwState.prevCode = prevCode; + lzwState.currentSequenceLength = currentSequenceLength; + this.bufferLength = currentBufferLength; + }; + LZWStream2.prototype.readBits = function(n) { + var bitsCached = this.bitsCached; + var cachedData = this.cachedData; + while (bitsCached < n) { + var c = this.stream.getByte(); + if (c === -1) { + this.eof = true; + return null; + } + cachedData = cachedData << 8 | c; + bitsCached += 8; + } + this.bitsCached = bitsCached -= n; + this.cachedData = cachedData; + return cachedData >>> bitsCached & (1 << n) - 1; + }; + return LZWStream2; + }(DecodeStream_default) +); +var LZWStream_default = LZWStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/RunLengthStream.js +var RunLengthStream = ( + /** @class */ + function(_super) { + __extends(RunLengthStream2, _super); + function RunLengthStream2(stream2, maybeLength) { + var _this = _super.call(this, maybeLength) || this; + _this.stream = stream2; + return _this; + } + RunLengthStream2.prototype.readBlock = function() { + var repeatHeader = this.stream.getBytes(2); + if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) { + this.eof = true; + return; + } + var buffer; + var bufferLength = this.bufferLength; + var n = repeatHeader[0]; + if (n < 128) { + buffer = this.ensureBuffer(bufferLength + n + 1); + buffer[bufferLength++] = repeatHeader[1]; + if (n > 0) { + var source = this.stream.getBytes(n); + buffer.set(source, bufferLength); + bufferLength += n; + } + } else { + n = 257 - n; + var b = repeatHeader[1]; + buffer = this.ensureBuffer(bufferLength + n + 1); + for (var i = 0; i < n; i++) { + buffer[bufferLength++] = b; + } + } + this.bufferLength = bufferLength; + }; + return RunLengthStream2; + }(DecodeStream_default) +); +var RunLengthStream_default = RunLengthStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/streams/decode.js +var decodeStream = function(stream2, encoding, params) { + if (encoding === PDFName_default.of("FlateDecode")) { + return new FlateStream_default(stream2); + } + if (encoding === PDFName_default.of("LZWDecode")) { + var earlyChange = 1; + if (params instanceof PDFDict_default) { + var EarlyChange = params.lookup(PDFName_default.of("EarlyChange")); + if (EarlyChange instanceof PDFNumber_default) { + earlyChange = EarlyChange.asNumber(); + } + } + return new LZWStream_default(stream2, void 0, earlyChange); + } + if (encoding === PDFName_default.of("ASCII85Decode")) { + return new Ascii85Stream_default(stream2); + } + if (encoding === PDFName_default.of("ASCIIHexDecode")) { + return new AsciiHexStream_default(stream2); + } + if (encoding === PDFName_default.of("RunLengthDecode")) { + return new RunLengthStream_default(stream2); + } + throw new UnsupportedEncodingError(encoding.asString()); +}; +var decodePDFRawStream = function(_a) { + var dict = _a.dict, contents = _a.contents; + var stream2 = new Stream_default(contents); + var Filter = dict.lookup(PDFName_default.of("Filter")); + var DecodeParms = dict.lookup(PDFName_default.of("DecodeParms")); + if (Filter instanceof PDFName_default) { + stream2 = decodeStream(stream2, Filter, DecodeParms); + } else if (Filter instanceof PDFArray_default) { + for (var idx = 0, len = Filter.size(); idx < len; idx++) { + stream2 = decodeStream(stream2, Filter.lookup(idx, PDFName_default), DecodeParms && DecodeParms.lookupMaybe(idx, PDFDict_default)); + } + } else if (!!Filter) { + throw new UnexpectedObjectTypeError([PDFName_default, PDFArray_default], Filter); + } + return stream2; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/PDFPageEmbedder.js +var fullPageBoundingBox = function(page) { + var mediaBox = page.MediaBox(); + var width = mediaBox.lookup(2, PDFNumber_default).asNumber() - mediaBox.lookup(0, PDFNumber_default).asNumber(); + var height = mediaBox.lookup(3, PDFNumber_default).asNumber() - mediaBox.lookup(1, PDFNumber_default).asNumber(); + return { left: 0, bottom: 0, right: width, top: height }; +}; +var boundingBoxAdjustedMatrix = function(bb) { + return [1, 0, 0, 1, -bb.left, -bb.bottom]; +}; +var PDFPageEmbedder = ( + /** @class */ + function() { + function PDFPageEmbedder2(page, boundingBox, transformationMatrix) { + this.page = page; + var bb = boundingBox !== null && boundingBox !== void 0 ? boundingBox : fullPageBoundingBox(page); + this.width = bb.right - bb.left; + this.height = bb.top - bb.bottom; + this.boundingBox = bb; + this.transformationMatrix = transformationMatrix !== null && transformationMatrix !== void 0 ? transformationMatrix : boundingBoxAdjustedMatrix(bb); + } + PDFPageEmbedder2.for = function(page, boundingBox, transformationMatrix) { + return __awaiter(this, void 0, void 0, function() { + return __generator(this, function(_a) { + return [2, new PDFPageEmbedder2(page, boundingBox, transformationMatrix)]; + }); + }); + }; + PDFPageEmbedder2.prototype.embedIntoContext = function(context, ref) { + return __awaiter(this, void 0, void 0, function() { + var _a, Contents, Resources, decodedContents, _b, left, bottom, right, top, xObject; + return __generator(this, function(_c) { + _a = this.page.normalizedEntries(), Contents = _a.Contents, Resources = _a.Resources; + if (!Contents) + throw new MissingPageContentsEmbeddingError(); + decodedContents = this.decodeContents(Contents); + _b = this.boundingBox, left = _b.left, bottom = _b.bottom, right = _b.right, top = _b.top; + xObject = context.flateStream(decodedContents, { + Type: "XObject", + Subtype: "Form", + FormType: 1, + BBox: [left, bottom, right, top], + Matrix: this.transformationMatrix, + Resources + }); + if (ref) { + context.assign(ref, xObject); + return [2, ref]; + } else { + return [2, context.register(xObject)]; + } + return [ + 2 + /*return*/ + ]; + }); + }); + }; + PDFPageEmbedder2.prototype.decodeContents = function(contents) { + var newline = Uint8Array.of(CharCodes_default.Newline); + var decodedContents = []; + for (var idx = 0, len = contents.size(); idx < len; idx++) { + var stream2 = contents.lookup(idx, PDFStream_default); + var content = void 0; + if (stream2 instanceof PDFRawStream_default) { + content = decodePDFRawStream(stream2).decode(); + } else if (stream2 instanceof PDFContentStream_default) { + content = stream2.getUnencodedContents(); + } else { + throw new UnrecognizedStreamTypeError(stream2); + } + decodedContents.push(content, newline); + } + return mergeIntoTypedArray.apply(void 0, decodedContents); + }; + return PDFPageEmbedder2; + }() +); +var PDFPageEmbedder_default = PDFPageEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/interactive/ViewerPreferences.js +var asEnum = function(rawValue, enumType) { + if (rawValue === void 0) + return void 0; + return enumType[rawValue]; +}; +var NonFullScreenPageMode; +(function(NonFullScreenPageMode2) { + NonFullScreenPageMode2["UseNone"] = "UseNone"; + NonFullScreenPageMode2["UseOutlines"] = "UseOutlines"; + NonFullScreenPageMode2["UseThumbs"] = "UseThumbs"; + NonFullScreenPageMode2["UseOC"] = "UseOC"; +})(NonFullScreenPageMode || (NonFullScreenPageMode = {})); +var ReadingDirection; +(function(ReadingDirection2) { + ReadingDirection2["L2R"] = "L2R"; + ReadingDirection2["R2L"] = "R2L"; +})(ReadingDirection || (ReadingDirection = {})); +var PrintScaling; +(function(PrintScaling2) { + PrintScaling2["None"] = "None"; + PrintScaling2["AppDefault"] = "AppDefault"; +})(PrintScaling || (PrintScaling = {})); +var Duplex; +(function(Duplex2) { + Duplex2["Simplex"] = "Simplex"; + Duplex2["DuplexFlipShortEdge"] = "DuplexFlipShortEdge"; + Duplex2["DuplexFlipLongEdge"] = "DuplexFlipLongEdge"; +})(Duplex || (Duplex = {})); +var ViewerPreferences = ( + /** @class */ + function() { + function ViewerPreferences2(dict) { + this.dict = dict; + } + ViewerPreferences2.prototype.lookupBool = function(key) { + var returnObj = this.dict.lookup(PDFName_default.of(key)); + if (returnObj instanceof PDFBool_default) + return returnObj; + return void 0; + }; + ViewerPreferences2.prototype.lookupName = function(key) { + var returnObj = this.dict.lookup(PDFName_default.of(key)); + if (returnObj instanceof PDFName_default) + return returnObj; + return void 0; + }; + ViewerPreferences2.prototype.HideToolbar = function() { + return this.lookupBool("HideToolbar"); + }; + ViewerPreferences2.prototype.HideMenubar = function() { + return this.lookupBool("HideMenubar"); + }; + ViewerPreferences2.prototype.HideWindowUI = function() { + return this.lookupBool("HideWindowUI"); + }; + ViewerPreferences2.prototype.FitWindow = function() { + return this.lookupBool("FitWindow"); + }; + ViewerPreferences2.prototype.CenterWindow = function() { + return this.lookupBool("CenterWindow"); + }; + ViewerPreferences2.prototype.DisplayDocTitle = function() { + return this.lookupBool("DisplayDocTitle"); + }; + ViewerPreferences2.prototype.NonFullScreenPageMode = function() { + return this.lookupName("NonFullScreenPageMode"); + }; + ViewerPreferences2.prototype.Direction = function() { + return this.lookupName("Direction"); + }; + ViewerPreferences2.prototype.PrintScaling = function() { + return this.lookupName("PrintScaling"); + }; + ViewerPreferences2.prototype.Duplex = function() { + return this.lookupName("Duplex"); + }; + ViewerPreferences2.prototype.PickTrayByPDFSize = function() { + return this.lookupBool("PickTrayByPDFSize"); + }; + ViewerPreferences2.prototype.PrintPageRange = function() { + var PrintPageRange = this.dict.lookup(PDFName_default.of("PrintPageRange")); + if (PrintPageRange instanceof PDFArray_default) + return PrintPageRange; + return void 0; + }; + ViewerPreferences2.prototype.NumCopies = function() { + var NumCopies = this.dict.lookup(PDFName_default.of("NumCopies")); + if (NumCopies instanceof PDFNumber_default) + return NumCopies; + return void 0; + }; + ViewerPreferences2.prototype.getHideToolbar = function() { + var _a, _b; + return (_b = (_a = this.HideToolbar()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false; + }; + ViewerPreferences2.prototype.getHideMenubar = function() { + var _a, _b; + return (_b = (_a = this.HideMenubar()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false; + }; + ViewerPreferences2.prototype.getHideWindowUI = function() { + var _a, _b; + return (_b = (_a = this.HideWindowUI()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false; + }; + ViewerPreferences2.prototype.getFitWindow = function() { + var _a, _b; + return (_b = (_a = this.FitWindow()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false; + }; + ViewerPreferences2.prototype.getCenterWindow = function() { + var _a, _b; + return (_b = (_a = this.CenterWindow()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false; + }; + ViewerPreferences2.prototype.getDisplayDocTitle = function() { + var _a, _b; + return (_b = (_a = this.DisplayDocTitle()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false; + }; + ViewerPreferences2.prototype.getNonFullScreenPageMode = function() { + var _a, _b; + var mode = (_a = this.NonFullScreenPageMode()) === null || _a === void 0 ? void 0 : _a.decodeText(); + return (_b = asEnum(mode, NonFullScreenPageMode)) !== null && _b !== void 0 ? _b : NonFullScreenPageMode.UseNone; + }; + ViewerPreferences2.prototype.getReadingDirection = function() { + var _a, _b; + var direction = (_a = this.Direction()) === null || _a === void 0 ? void 0 : _a.decodeText(); + return (_b = asEnum(direction, ReadingDirection)) !== null && _b !== void 0 ? _b : ReadingDirection.L2R; + }; + ViewerPreferences2.prototype.getPrintScaling = function() { + var _a, _b; + var scaling = (_a = this.PrintScaling()) === null || _a === void 0 ? void 0 : _a.decodeText(); + return (_b = asEnum(scaling, PrintScaling)) !== null && _b !== void 0 ? _b : PrintScaling.AppDefault; + }; + ViewerPreferences2.prototype.getDuplex = function() { + var _a; + var duplex = (_a = this.Duplex()) === null || _a === void 0 ? void 0 : _a.decodeText(); + return asEnum(duplex, Duplex); + }; + ViewerPreferences2.prototype.getPickTrayByPDFSize = function() { + var _a; + return (_a = this.PickTrayByPDFSize()) === null || _a === void 0 ? void 0 : _a.asBoolean(); + }; + ViewerPreferences2.prototype.getPrintPageRange = function() { + var rng = this.PrintPageRange(); + if (!rng) + return []; + var pageRanges = []; + for (var i = 0; i < rng.size(); i += 2) { + var start = rng.lookup(i, PDFNumber_default).asNumber(); + var end = rng.lookup(i + 1, PDFNumber_default).asNumber(); + pageRanges.push({ start, end }); + } + return pageRanges; + }; + ViewerPreferences2.prototype.getNumCopies = function() { + var _a, _b; + return (_b = (_a = this.NumCopies()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 1; + }; + ViewerPreferences2.prototype.setHideToolbar = function(hideToolbar) { + var HideToolbar = this.dict.context.obj(hideToolbar); + this.dict.set(PDFName_default.of("HideToolbar"), HideToolbar); + }; + ViewerPreferences2.prototype.setHideMenubar = function(hideMenubar) { + var HideMenubar = this.dict.context.obj(hideMenubar); + this.dict.set(PDFName_default.of("HideMenubar"), HideMenubar); + }; + ViewerPreferences2.prototype.setHideWindowUI = function(hideWindowUI) { + var HideWindowUI = this.dict.context.obj(hideWindowUI); + this.dict.set(PDFName_default.of("HideWindowUI"), HideWindowUI); + }; + ViewerPreferences2.prototype.setFitWindow = function(fitWindow) { + var FitWindow = this.dict.context.obj(fitWindow); + this.dict.set(PDFName_default.of("FitWindow"), FitWindow); + }; + ViewerPreferences2.prototype.setCenterWindow = function(centerWindow) { + var CenterWindow = this.dict.context.obj(centerWindow); + this.dict.set(PDFName_default.of("CenterWindow"), CenterWindow); + }; + ViewerPreferences2.prototype.setDisplayDocTitle = function(displayTitle) { + var DisplayDocTitle = this.dict.context.obj(displayTitle); + this.dict.set(PDFName_default.of("DisplayDocTitle"), DisplayDocTitle); + }; + ViewerPreferences2.prototype.setNonFullScreenPageMode = function(nonFullScreenPageMode) { + assertIsOneOf(nonFullScreenPageMode, "nonFullScreenPageMode", NonFullScreenPageMode); + var mode = PDFName_default.of(nonFullScreenPageMode); + this.dict.set(PDFName_default.of("NonFullScreenPageMode"), mode); + }; + ViewerPreferences2.prototype.setReadingDirection = function(readingDirection) { + assertIsOneOf(readingDirection, "readingDirection", ReadingDirection); + var direction = PDFName_default.of(readingDirection); + this.dict.set(PDFName_default.of("Direction"), direction); + }; + ViewerPreferences2.prototype.setPrintScaling = function(printScaling) { + assertIsOneOf(printScaling, "printScaling", PrintScaling); + var scaling = PDFName_default.of(printScaling); + this.dict.set(PDFName_default.of("PrintScaling"), scaling); + }; + ViewerPreferences2.prototype.setDuplex = function(duplex) { + assertIsOneOf(duplex, "duplex", Duplex); + var dup = PDFName_default.of(duplex); + this.dict.set(PDFName_default.of("Duplex"), dup); + }; + ViewerPreferences2.prototype.setPickTrayByPDFSize = function(pickTrayByPDFSize) { + var PickTrayByPDFSize = this.dict.context.obj(pickTrayByPDFSize); + this.dict.set(PDFName_default.of("PickTrayByPDFSize"), PickTrayByPDFSize); + }; + ViewerPreferences2.prototype.setPrintPageRange = function(printPageRange) { + if (!Array.isArray(printPageRange)) + printPageRange = [printPageRange]; + var flatRange = []; + for (var idx = 0, len = printPageRange.length; idx < len; idx++) { + flatRange.push(printPageRange[idx].start); + flatRange.push(printPageRange[idx].end); + } + assertEachIs(flatRange, "printPageRange", ["number"]); + var pageRanges = this.dict.context.obj(flatRange); + this.dict.set(PDFName_default.of("PrintPageRange"), pageRanges); + }; + ViewerPreferences2.prototype.setNumCopies = function(numCopies) { + assertRange(numCopies, "numCopies", 1, Number.MAX_VALUE); + assertInteger(numCopies, "numCopies"); + var NumCopies = this.dict.context.obj(numCopies); + this.dict.set(PDFName_default.of("NumCopies"), NumCopies); + }; + ViewerPreferences2.fromDict = function(dict) { + return new ViewerPreferences2(dict); + }; + ViewerPreferences2.create = function(context) { + var dict = context.obj({}); + return new ViewerPreferences2(dict); + }; + return ViewerPreferences2; + }() +); +var ViewerPreferences_default = ViewerPreferences; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroField.js +var tfRegex = /\/([^\0\t\n\f\r\ ]+)[\0\t\n\f\r\ ]*(\d*\.\d+|\d+)?[\0\t\n\f\r\ ]+Tf/; +var PDFAcroField = ( + /** @class */ + function() { + function PDFAcroField2(dict, ref) { + this.dict = dict; + this.ref = ref; + } + PDFAcroField2.prototype.T = function() { + return this.dict.lookupMaybe(PDFName_default.of("T"), PDFString_default, PDFHexString_default); + }; + PDFAcroField2.prototype.Ff = function() { + var numberOrRef = this.getInheritableAttribute(PDFName_default.of("Ff")); + return this.dict.context.lookupMaybe(numberOrRef, PDFNumber_default); + }; + PDFAcroField2.prototype.V = function() { + var valueOrRef = this.getInheritableAttribute(PDFName_default.of("V")); + return this.dict.context.lookup(valueOrRef); + }; + PDFAcroField2.prototype.Kids = function() { + return this.dict.lookupMaybe(PDFName_default.of("Kids"), PDFArray_default); + }; + PDFAcroField2.prototype.DA = function() { + var da = this.dict.lookup(PDFName_default.of("DA")); + if (da instanceof PDFString_default || da instanceof PDFHexString_default) + return da; + return void 0; + }; + PDFAcroField2.prototype.setKids = function(kids) { + this.dict.set(PDFName_default.of("Kids"), this.dict.context.obj(kids)); + }; + PDFAcroField2.prototype.getParent = function() { + var parentRef = this.dict.get(PDFName_default.of("Parent")); + if (parentRef instanceof PDFRef_default) { + var parent_1 = this.dict.lookup(PDFName_default.of("Parent"), PDFDict_default); + return new PDFAcroField2(parent_1, parentRef); + } + return void 0; + }; + PDFAcroField2.prototype.setParent = function(parent) { + if (!parent) + this.dict.delete(PDFName_default.of("Parent")); + else + this.dict.set(PDFName_default.of("Parent"), parent); + }; + PDFAcroField2.prototype.getFullyQualifiedName = function() { + var parent = this.getParent(); + if (!parent) + return this.getPartialName(); + return parent.getFullyQualifiedName() + "." + this.getPartialName(); + }; + PDFAcroField2.prototype.getPartialName = function() { + var _a; + return (_a = this.T()) === null || _a === void 0 ? void 0 : _a.decodeText(); + }; + PDFAcroField2.prototype.setPartialName = function(partialName) { + if (!partialName) + this.dict.delete(PDFName_default.of("T")); + else + this.dict.set(PDFName_default.of("T"), PDFHexString_default.fromText(partialName)); + }; + PDFAcroField2.prototype.setDefaultAppearance = function(appearance) { + this.dict.set(PDFName_default.of("DA"), PDFString_default.of(appearance)); + }; + PDFAcroField2.prototype.getDefaultAppearance = function() { + var DA = this.DA(); + if (DA instanceof PDFHexString_default) { + return DA.decodeText(); + } + return DA === null || DA === void 0 ? void 0 : DA.asString(); + }; + PDFAcroField2.prototype.setFontSize = function(fontSize) { + var _a; + var name = (_a = this.getFullyQualifiedName()) !== null && _a !== void 0 ? _a : ""; + var da = this.getDefaultAppearance(); + if (!da) + throw new MissingDAEntryError(name); + var daMatch = findLastMatch(da, tfRegex); + if (!daMatch.match) + throw new MissingTfOperatorError(name); + var daStart = da.slice(0, daMatch.pos - daMatch.match[0].length); + var daEnd = daMatch.pos <= da.length ? da.slice(daMatch.pos) : ""; + var fontName = daMatch.match[1]; + var modifiedDa = daStart + " /" + fontName + " " + fontSize + " Tf " + daEnd; + this.setDefaultAppearance(modifiedDa); + }; + PDFAcroField2.prototype.getFlags = function() { + var _a, _b; + return (_b = (_a = this.Ff()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 0; + }; + PDFAcroField2.prototype.setFlags = function(flags) { + this.dict.set(PDFName_default.of("Ff"), PDFNumber_default.of(flags)); + }; + PDFAcroField2.prototype.hasFlag = function(flag3) { + var flags = this.getFlags(); + return (flags & flag3) !== 0; + }; + PDFAcroField2.prototype.setFlag = function(flag3) { + var flags = this.getFlags(); + this.setFlags(flags | flag3); + }; + PDFAcroField2.prototype.clearFlag = function(flag3) { + var flags = this.getFlags(); + this.setFlags(flags & ~flag3); + }; + PDFAcroField2.prototype.setFlagTo = function(flag3, enable) { + if (enable) + this.setFlag(flag3); + else + this.clearFlag(flag3); + }; + PDFAcroField2.prototype.getInheritableAttribute = function(name) { + var attribute; + this.ascend(function(node) { + if (!attribute) + attribute = node.dict.get(name); + }); + return attribute; + }; + PDFAcroField2.prototype.ascend = function(visitor) { + visitor(this); + var parent = this.getParent(); + if (parent) + parent.ascend(visitor); + }; + return PDFAcroField2; + }() +); +var PDFAcroField_default = PDFAcroField; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/annotation/BorderStyle.js +var BorderStyle = ( + /** @class */ + function() { + function BorderStyle2(dict) { + this.dict = dict; + } + BorderStyle2.prototype.W = function() { + var W = this.dict.lookup(PDFName_default.of("W")); + if (W instanceof PDFNumber_default) + return W; + return void 0; + }; + BorderStyle2.prototype.getWidth = function() { + var _a, _b; + return (_b = (_a = this.W()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 1; + }; + BorderStyle2.prototype.setWidth = function(width) { + var W = this.dict.context.obj(width); + this.dict.set(PDFName_default.of("W"), W); + }; + BorderStyle2.fromDict = function(dict) { + return new BorderStyle2(dict); + }; + return BorderStyle2; + }() +); +var BorderStyle_default = BorderStyle; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/annotation/PDFAnnotation.js +var PDFAnnotation = ( + /** @class */ + function() { + function PDFAnnotation2(dict) { + this.dict = dict; + } + PDFAnnotation2.prototype.Rect = function() { + return this.dict.lookup(PDFName_default.of("Rect"), PDFArray_default); + }; + PDFAnnotation2.prototype.AP = function() { + return this.dict.lookupMaybe(PDFName_default.of("AP"), PDFDict_default); + }; + PDFAnnotation2.prototype.F = function() { + var numberOrRef = this.dict.lookup(PDFName_default.of("F")); + return this.dict.context.lookupMaybe(numberOrRef, PDFNumber_default); + }; + PDFAnnotation2.prototype.getRectangle = function() { + var _a; + var Rect = this.Rect(); + return (_a = Rect === null || Rect === void 0 ? void 0 : Rect.asRectangle()) !== null && _a !== void 0 ? _a : { x: 0, y: 0, width: 0, height: 0 }; + }; + PDFAnnotation2.prototype.setRectangle = function(rect) { + var x = rect.x, y = rect.y, width = rect.width, height = rect.height; + var Rect = this.dict.context.obj([x, y, x + width, y + height]); + this.dict.set(PDFName_default.of("Rect"), Rect); + }; + PDFAnnotation2.prototype.getAppearanceState = function() { + var AS = this.dict.lookup(PDFName_default.of("AS")); + if (AS instanceof PDFName_default) + return AS; + return void 0; + }; + PDFAnnotation2.prototype.setAppearanceState = function(state) { + this.dict.set(PDFName_default.of("AS"), state); + }; + PDFAnnotation2.prototype.setAppearances = function(appearances) { + this.dict.set(PDFName_default.of("AP"), appearances); + }; + PDFAnnotation2.prototype.ensureAP = function() { + var AP = this.AP(); + if (!AP) { + AP = this.dict.context.obj({}); + this.dict.set(PDFName_default.of("AP"), AP); + } + return AP; + }; + PDFAnnotation2.prototype.getNormalAppearance = function() { + var AP = this.ensureAP(); + var N = AP.get(PDFName_default.of("N")); + if (N instanceof PDFRef_default || N instanceof PDFDict_default) + return N; + throw new Error("Unexpected N type: " + (N === null || N === void 0 ? void 0 : N.constructor.name)); + }; + PDFAnnotation2.prototype.setNormalAppearance = function(appearance) { + var AP = this.ensureAP(); + AP.set(PDFName_default.of("N"), appearance); + }; + PDFAnnotation2.prototype.setRolloverAppearance = function(appearance) { + var AP = this.ensureAP(); + AP.set(PDFName_default.of("R"), appearance); + }; + PDFAnnotation2.prototype.setDownAppearance = function(appearance) { + var AP = this.ensureAP(); + AP.set(PDFName_default.of("D"), appearance); + }; + PDFAnnotation2.prototype.removeRolloverAppearance = function() { + var AP = this.AP(); + AP === null || AP === void 0 ? void 0 : AP.delete(PDFName_default.of("R")); + }; + PDFAnnotation2.prototype.removeDownAppearance = function() { + var AP = this.AP(); + AP === null || AP === void 0 ? void 0 : AP.delete(PDFName_default.of("D")); + }; + PDFAnnotation2.prototype.getAppearances = function() { + var AP = this.AP(); + if (!AP) + return void 0; + var N = AP.lookup(PDFName_default.of("N"), PDFDict_default, PDFStream_default); + var R = AP.lookupMaybe(PDFName_default.of("R"), PDFDict_default, PDFStream_default); + var D = AP.lookupMaybe(PDFName_default.of("D"), PDFDict_default, PDFStream_default); + return { normal: N, rollover: R, down: D }; + }; + PDFAnnotation2.prototype.getFlags = function() { + var _a, _b; + return (_b = (_a = this.F()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 0; + }; + PDFAnnotation2.prototype.setFlags = function(flags) { + this.dict.set(PDFName_default.of("F"), PDFNumber_default.of(flags)); + }; + PDFAnnotation2.prototype.hasFlag = function(flag3) { + var flags = this.getFlags(); + return (flags & flag3) !== 0; + }; + PDFAnnotation2.prototype.setFlag = function(flag3) { + var flags = this.getFlags(); + this.setFlags(flags | flag3); + }; + PDFAnnotation2.prototype.clearFlag = function(flag3) { + var flags = this.getFlags(); + this.setFlags(flags & ~flag3); + }; + PDFAnnotation2.prototype.setFlagTo = function(flag3, enable) { + if (enable) + this.setFlag(flag3); + else + this.clearFlag(flag3); + }; + PDFAnnotation2.fromDict = function(dict) { + return new PDFAnnotation2(dict); + }; + return PDFAnnotation2; + }() +); +var PDFAnnotation_default = PDFAnnotation; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/annotation/AppearanceCharacteristics.js +var AppearanceCharacteristics = ( + /** @class */ + function() { + function AppearanceCharacteristics2(dict) { + this.dict = dict; + } + AppearanceCharacteristics2.prototype.R = function() { + var R = this.dict.lookup(PDFName_default.of("R")); + if (R instanceof PDFNumber_default) + return R; + return void 0; + }; + AppearanceCharacteristics2.prototype.BC = function() { + var BC = this.dict.lookup(PDFName_default.of("BC")); + if (BC instanceof PDFArray_default) + return BC; + return void 0; + }; + AppearanceCharacteristics2.prototype.BG = function() { + var BG = this.dict.lookup(PDFName_default.of("BG")); + if (BG instanceof PDFArray_default) + return BG; + return void 0; + }; + AppearanceCharacteristics2.prototype.CA = function() { + var CA = this.dict.lookup(PDFName_default.of("CA")); + if (CA instanceof PDFHexString_default || CA instanceof PDFString_default) + return CA; + return void 0; + }; + AppearanceCharacteristics2.prototype.RC = function() { + var RC = this.dict.lookup(PDFName_default.of("RC")); + if (RC instanceof PDFHexString_default || RC instanceof PDFString_default) + return RC; + return void 0; + }; + AppearanceCharacteristics2.prototype.AC = function() { + var AC = this.dict.lookup(PDFName_default.of("AC")); + if (AC instanceof PDFHexString_default || AC instanceof PDFString_default) + return AC; + return void 0; + }; + AppearanceCharacteristics2.prototype.getRotation = function() { + var _a; + return (_a = this.R()) === null || _a === void 0 ? void 0 : _a.asNumber(); + }; + AppearanceCharacteristics2.prototype.getBorderColor = function() { + var BC = this.BC(); + if (!BC) + return void 0; + var components = []; + for (var idx = 0, len = BC === null || BC === void 0 ? void 0 : BC.size(); idx < len; idx++) { + var component = BC.get(idx); + if (component instanceof PDFNumber_default) + components.push(component.asNumber()); + } + return components; + }; + AppearanceCharacteristics2.prototype.getBackgroundColor = function() { + var BG = this.BG(); + if (!BG) + return void 0; + var components = []; + for (var idx = 0, len = BG === null || BG === void 0 ? void 0 : BG.size(); idx < len; idx++) { + var component = BG.get(idx); + if (component instanceof PDFNumber_default) + components.push(component.asNumber()); + } + return components; + }; + AppearanceCharacteristics2.prototype.getCaptions = function() { + var CA = this.CA(); + var RC = this.RC(); + var AC = this.AC(); + return { + normal: CA === null || CA === void 0 ? void 0 : CA.decodeText(), + rollover: RC === null || RC === void 0 ? void 0 : RC.decodeText(), + down: AC === null || AC === void 0 ? void 0 : AC.decodeText() + }; + }; + AppearanceCharacteristics2.prototype.setRotation = function(rotation) { + var R = this.dict.context.obj(rotation); + this.dict.set(PDFName_default.of("R"), R); + }; + AppearanceCharacteristics2.prototype.setBorderColor = function(color) { + var BC = this.dict.context.obj(color); + this.dict.set(PDFName_default.of("BC"), BC); + }; + AppearanceCharacteristics2.prototype.setBackgroundColor = function(color) { + var BG = this.dict.context.obj(color); + this.dict.set(PDFName_default.of("BG"), BG); + }; + AppearanceCharacteristics2.prototype.setCaptions = function(captions) { + var CA = PDFHexString_default.fromText(captions.normal); + this.dict.set(PDFName_default.of("CA"), CA); + if (captions.rollover) { + var RC = PDFHexString_default.fromText(captions.rollover); + this.dict.set(PDFName_default.of("RC"), RC); + } else { + this.dict.delete(PDFName_default.of("RC")); + } + if (captions.down) { + var AC = PDFHexString_default.fromText(captions.down); + this.dict.set(PDFName_default.of("AC"), AC); + } else { + this.dict.delete(PDFName_default.of("AC")); + } + }; + AppearanceCharacteristics2.fromDict = function(dict) { + return new AppearanceCharacteristics2(dict); + }; + return AppearanceCharacteristics2; + }() +); +var AppearanceCharacteristics_default = AppearanceCharacteristics; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/annotation/PDFWidgetAnnotation.js +var PDFWidgetAnnotation = ( + /** @class */ + function(_super) { + __extends(PDFWidgetAnnotation2, _super); + function PDFWidgetAnnotation2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFWidgetAnnotation2.prototype.MK = function() { + var MK = this.dict.lookup(PDFName_default.of("MK")); + if (MK instanceof PDFDict_default) + return MK; + return void 0; + }; + PDFWidgetAnnotation2.prototype.BS = function() { + var BS = this.dict.lookup(PDFName_default.of("BS")); + if (BS instanceof PDFDict_default) + return BS; + return void 0; + }; + PDFWidgetAnnotation2.prototype.DA = function() { + var da = this.dict.lookup(PDFName_default.of("DA")); + if (da instanceof PDFString_default || da instanceof PDFHexString_default) + return da; + return void 0; + }; + PDFWidgetAnnotation2.prototype.P = function() { + var P = this.dict.get(PDFName_default.of("P")); + if (P instanceof PDFRef_default) + return P; + return void 0; + }; + PDFWidgetAnnotation2.prototype.setP = function(page) { + this.dict.set(PDFName_default.of("P"), page); + }; + PDFWidgetAnnotation2.prototype.setDefaultAppearance = function(appearance) { + this.dict.set(PDFName_default.of("DA"), PDFString_default.of(appearance)); + }; + PDFWidgetAnnotation2.prototype.getDefaultAppearance = function() { + var DA = this.DA(); + if (DA instanceof PDFHexString_default) { + return DA.decodeText(); + } + return DA === null || DA === void 0 ? void 0 : DA.asString(); + }; + PDFWidgetAnnotation2.prototype.getAppearanceCharacteristics = function() { + var MK = this.MK(); + if (MK) + return AppearanceCharacteristics_default.fromDict(MK); + return void 0; + }; + PDFWidgetAnnotation2.prototype.getOrCreateAppearanceCharacteristics = function() { + var MK = this.MK(); + if (MK) + return AppearanceCharacteristics_default.fromDict(MK); + var ac = AppearanceCharacteristics_default.fromDict(this.dict.context.obj({})); + this.dict.set(PDFName_default.of("MK"), ac.dict); + return ac; + }; + PDFWidgetAnnotation2.prototype.getBorderStyle = function() { + var BS = this.BS(); + if (BS) + return BorderStyle_default.fromDict(BS); + return void 0; + }; + PDFWidgetAnnotation2.prototype.getOrCreateBorderStyle = function() { + var BS = this.BS(); + if (BS) + return BorderStyle_default.fromDict(BS); + var bs = BorderStyle_default.fromDict(this.dict.context.obj({})); + this.dict.set(PDFName_default.of("BS"), bs.dict); + return bs; + }; + PDFWidgetAnnotation2.prototype.getOnValue = function() { + var _a; + var normal = (_a = this.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal; + if (normal instanceof PDFDict_default) { + var keys = normal.keys(); + for (var idx = 0, len = keys.length; idx < len; idx++) { + var key = keys[idx]; + if (key !== PDFName_default.of("Off")) + return key; + } + } + return void 0; + }; + PDFWidgetAnnotation2.fromDict = function(dict) { + return new PDFWidgetAnnotation2(dict); + }; + PDFWidgetAnnotation2.create = function(context, parent) { + var dict = context.obj({ + Type: "Annot", + Subtype: "Widget", + Rect: [0, 0, 0, 0], + Parent: parent + }); + return new PDFWidgetAnnotation2(dict); + }; + return PDFWidgetAnnotation2; + }(PDFAnnotation_default) +); +var PDFWidgetAnnotation_default = PDFWidgetAnnotation; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroTerminal.js +var PDFAcroTerminal = ( + /** @class */ + function(_super) { + __extends(PDFAcroTerminal2, _super); + function PDFAcroTerminal2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroTerminal2.prototype.FT = function() { + var nameOrRef = this.getInheritableAttribute(PDFName_default.of("FT")); + return this.dict.context.lookup(nameOrRef, PDFName_default); + }; + PDFAcroTerminal2.prototype.getWidgets = function() { + var kidDicts = this.Kids(); + if (!kidDicts) + return [PDFWidgetAnnotation_default.fromDict(this.dict)]; + var widgets = new Array(kidDicts.size()); + for (var idx = 0, len = kidDicts.size(); idx < len; idx++) { + var dict = kidDicts.lookup(idx, PDFDict_default); + widgets[idx] = PDFWidgetAnnotation_default.fromDict(dict); + } + return widgets; + }; + PDFAcroTerminal2.prototype.addWidget = function(ref) { + var Kids = this.normalizedEntries().Kids; + Kids.push(ref); + }; + PDFAcroTerminal2.prototype.removeWidget = function(idx) { + var kidDicts = this.Kids(); + if (!kidDicts) { + if (idx !== 0) + throw new IndexOutOfBoundsError(idx, 0, 0); + this.setKids([]); + } else { + if (idx < 0 || idx > kidDicts.size()) { + throw new IndexOutOfBoundsError(idx, 0, kidDicts.size()); + } + kidDicts.remove(idx); + } + }; + PDFAcroTerminal2.prototype.normalizedEntries = function() { + var Kids = this.Kids(); + if (!Kids) { + Kids = this.dict.context.obj([this.ref]); + this.dict.set(PDFName_default.of("Kids"), Kids); + } + return { Kids }; + }; + PDFAcroTerminal2.fromDict = function(dict, ref) { + return new PDFAcroTerminal2(dict, ref); + }; + return PDFAcroTerminal2; + }(PDFAcroField_default) +); +var PDFAcroTerminal_default = PDFAcroTerminal; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroButton.js +var PDFAcroButton = ( + /** @class */ + function(_super) { + __extends(PDFAcroButton2, _super); + function PDFAcroButton2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroButton2.prototype.Opt = function() { + return this.dict.lookupMaybe(PDFName_default.of("Opt"), PDFString_default, PDFHexString_default, PDFArray_default); + }; + PDFAcroButton2.prototype.setOpt = function(opt) { + this.dict.set(PDFName_default.of("Opt"), this.dict.context.obj(opt)); + }; + PDFAcroButton2.prototype.getExportValues = function() { + var opt = this.Opt(); + if (!opt) + return void 0; + if (opt instanceof PDFString_default || opt instanceof PDFHexString_default) { + return [opt]; + } + var values2 = []; + for (var idx = 0, len = opt.size(); idx < len; idx++) { + var value = opt.lookup(idx); + if (value instanceof PDFString_default || value instanceof PDFHexString_default) { + values2.push(value); + } + } + return values2; + }; + PDFAcroButton2.prototype.removeExportValue = function(idx) { + var opt = this.Opt(); + if (!opt) + return; + if (opt instanceof PDFString_default || opt instanceof PDFHexString_default) { + if (idx !== 0) + throw new IndexOutOfBoundsError(idx, 0, 0); + this.setOpt([]); + } else { + if (idx < 0 || idx > opt.size()) { + throw new IndexOutOfBoundsError(idx, 0, opt.size()); + } + opt.remove(idx); + } + }; + PDFAcroButton2.prototype.normalizeExportValues = function() { + var _a, _b, _c, _d; + var exportValues = (_a = this.getExportValues()) !== null && _a !== void 0 ? _a : []; + var Opt = []; + var widgets = this.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var exportVal = (_b = exportValues[idx]) !== null && _b !== void 0 ? _b : PDFHexString_default.fromText((_d = (_c = widget.getOnValue()) === null || _c === void 0 ? void 0 : _c.decodeText()) !== null && _d !== void 0 ? _d : ""); + Opt.push(exportVal); + } + this.setOpt(Opt); + }; + PDFAcroButton2.prototype.addOpt = function(opt, useExistingOptIdx) { + var _a; + this.normalizeExportValues(); + var optText = opt.decodeText(); + var existingIdx; + if (useExistingOptIdx) { + var exportValues = (_a = this.getExportValues()) !== null && _a !== void 0 ? _a : []; + for (var idx = 0, len = exportValues.length; idx < len; idx++) { + var exportVal = exportValues[idx]; + if (exportVal.decodeText() === optText) + existingIdx = idx; + } + } + var Opt = this.Opt(); + Opt.push(opt); + return existingIdx !== null && existingIdx !== void 0 ? existingIdx : Opt.size() - 1; + }; + PDFAcroButton2.prototype.addWidgetWithOpt = function(widget, opt, useExistingOptIdx) { + var optIdx = this.addOpt(opt, useExistingOptIdx); + var apStateValue = PDFName_default.of(String(optIdx)); + this.addWidget(widget); + return apStateValue; + }; + return PDFAcroButton2; + }(PDFAcroTerminal_default) +); +var PDFAcroButton_default = PDFAcroButton; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroCheckBox.js +var PDFAcroCheckBox = ( + /** @class */ + function(_super) { + __extends(PDFAcroCheckBox2, _super); + function PDFAcroCheckBox2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroCheckBox2.prototype.setValue = function(value) { + var _a; + var onValue = (_a = this.getOnValue()) !== null && _a !== void 0 ? _a : PDFName_default.of("Yes"); + if (value !== onValue && value !== PDFName_default.of("Off")) { + throw new InvalidAcroFieldValueError(); + } + this.dict.set(PDFName_default.of("V"), value); + var widgets = this.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var state = widget.getOnValue() === value ? value : PDFName_default.of("Off"); + widget.setAppearanceState(state); + } + }; + PDFAcroCheckBox2.prototype.getValue = function() { + var v = this.V(); + if (v instanceof PDFName_default) + return v; + return PDFName_default.of("Off"); + }; + PDFAcroCheckBox2.prototype.getOnValue = function() { + var widget = this.getWidgets()[0]; + return widget === null || widget === void 0 ? void 0 : widget.getOnValue(); + }; + PDFAcroCheckBox2.fromDict = function(dict, ref) { + return new PDFAcroCheckBox2(dict, ref); + }; + PDFAcroCheckBox2.create = function(context) { + var dict = context.obj({ + FT: "Btn", + Kids: [] + }); + var ref = context.register(dict); + return new PDFAcroCheckBox2(dict, ref); + }; + return PDFAcroCheckBox2; + }(PDFAcroButton_default) +); +var PDFAcroCheckBox_default = PDFAcroCheckBox; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/flags.js +var flag = function(bitIndex) { + return 1 << bitIndex; +}; +var AcroFieldFlags; +(function(AcroFieldFlags2) { + AcroFieldFlags2[AcroFieldFlags2["ReadOnly"] = flag(1 - 1)] = "ReadOnly"; + AcroFieldFlags2[AcroFieldFlags2["Required"] = flag(2 - 1)] = "Required"; + AcroFieldFlags2[AcroFieldFlags2["NoExport"] = flag(3 - 1)] = "NoExport"; +})(AcroFieldFlags || (AcroFieldFlags = {})); +var AcroButtonFlags; +(function(AcroButtonFlags2) { + AcroButtonFlags2[AcroButtonFlags2["NoToggleToOff"] = flag(15 - 1)] = "NoToggleToOff"; + AcroButtonFlags2[AcroButtonFlags2["Radio"] = flag(16 - 1)] = "Radio"; + AcroButtonFlags2[AcroButtonFlags2["PushButton"] = flag(17 - 1)] = "PushButton"; + AcroButtonFlags2[AcroButtonFlags2["RadiosInUnison"] = flag(26 - 1)] = "RadiosInUnison"; +})(AcroButtonFlags || (AcroButtonFlags = {})); +var AcroTextFlags; +(function(AcroTextFlags2) { + AcroTextFlags2[AcroTextFlags2["Multiline"] = flag(13 - 1)] = "Multiline"; + AcroTextFlags2[AcroTextFlags2["Password"] = flag(14 - 1)] = "Password"; + AcroTextFlags2[AcroTextFlags2["FileSelect"] = flag(21 - 1)] = "FileSelect"; + AcroTextFlags2[AcroTextFlags2["DoNotSpellCheck"] = flag(23 - 1)] = "DoNotSpellCheck"; + AcroTextFlags2[AcroTextFlags2["DoNotScroll"] = flag(24 - 1)] = "DoNotScroll"; + AcroTextFlags2[AcroTextFlags2["Comb"] = flag(25 - 1)] = "Comb"; + AcroTextFlags2[AcroTextFlags2["RichText"] = flag(26 - 1)] = "RichText"; +})(AcroTextFlags || (AcroTextFlags = {})); +var AcroChoiceFlags; +(function(AcroChoiceFlags2) { + AcroChoiceFlags2[AcroChoiceFlags2["Combo"] = flag(18 - 1)] = "Combo"; + AcroChoiceFlags2[AcroChoiceFlags2["Edit"] = flag(19 - 1)] = "Edit"; + AcroChoiceFlags2[AcroChoiceFlags2["Sort"] = flag(20 - 1)] = "Sort"; + AcroChoiceFlags2[AcroChoiceFlags2["MultiSelect"] = flag(22 - 1)] = "MultiSelect"; + AcroChoiceFlags2[AcroChoiceFlags2["DoNotSpellCheck"] = flag(23 - 1)] = "DoNotSpellCheck"; + AcroChoiceFlags2[AcroChoiceFlags2["CommitOnSelChange"] = flag(27 - 1)] = "CommitOnSelChange"; +})(AcroChoiceFlags || (AcroChoiceFlags = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroChoice.js +var PDFAcroChoice = ( + /** @class */ + function(_super) { + __extends(PDFAcroChoice2, _super); + function PDFAcroChoice2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroChoice2.prototype.setValues = function(values2) { + if (this.hasFlag(AcroChoiceFlags.Combo) && !this.hasFlag(AcroChoiceFlags.Edit) && !this.valuesAreValid(values2)) { + throw new InvalidAcroFieldValueError(); + } + if (values2.length === 0) { + this.dict.delete(PDFName_default.of("V")); + } + if (values2.length === 1) { + this.dict.set(PDFName_default.of("V"), values2[0]); + } + if (values2.length > 1) { + if (!this.hasFlag(AcroChoiceFlags.MultiSelect)) { + throw new MultiSelectValueError(); + } + this.dict.set(PDFName_default.of("V"), this.dict.context.obj(values2)); + } + this.updateSelectedIndices(values2); + }; + PDFAcroChoice2.prototype.valuesAreValid = function(values2) { + var options = this.getOptions(); + var _loop_1 = function(idx2, len2) { + var val = values2[idx2].decodeText(); + if (!options.find(function(o) { + return val === (o.display || o.value).decodeText(); + })) { + return { value: false }; + } + }; + for (var idx = 0, len = values2.length; idx < len; idx++) { + var state_1 = _loop_1(idx, len); + if (typeof state_1 === "object") + return state_1.value; + } + return true; + }; + PDFAcroChoice2.prototype.updateSelectedIndices = function(values2) { + if (values2.length > 1) { + var indices = new Array(values2.length); + var options = this.getOptions(); + var _loop_2 = function(idx2, len2) { + var val = values2[idx2].decodeText(); + indices[idx2] = options.findIndex(function(o) { + return val === (o.display || o.value).decodeText(); + }); + }; + for (var idx = 0, len = values2.length; idx < len; idx++) { + _loop_2(idx, len); + } + this.dict.set(PDFName_default.of("I"), this.dict.context.obj(indices.sort())); + } else { + this.dict.delete(PDFName_default.of("I")); + } + }; + PDFAcroChoice2.prototype.getValues = function() { + var v = this.V(); + if (v instanceof PDFString_default || v instanceof PDFHexString_default) + return [v]; + if (v instanceof PDFArray_default) { + var values2 = []; + for (var idx = 0, len = v.size(); idx < len; idx++) { + var value = v.lookup(idx); + if (value instanceof PDFString_default || value instanceof PDFHexString_default) { + values2.push(value); + } + } + return values2; + } + return []; + }; + PDFAcroChoice2.prototype.Opt = function() { + return this.dict.lookupMaybe(PDFName_default.of("Opt"), PDFString_default, PDFHexString_default, PDFArray_default); + }; + PDFAcroChoice2.prototype.setOptions = function(options) { + var newOpt = new Array(options.length); + for (var idx = 0, len = options.length; idx < len; idx++) { + var _a = options[idx], value = _a.value, display = _a.display; + newOpt[idx] = this.dict.context.obj([value, display || value]); + } + this.dict.set(PDFName_default.of("Opt"), this.dict.context.obj(newOpt)); + }; + PDFAcroChoice2.prototype.getOptions = function() { + var Opt = this.Opt(); + if (Opt instanceof PDFString_default || Opt instanceof PDFHexString_default) { + return [{ value: Opt, display: Opt }]; + } + if (Opt instanceof PDFArray_default) { + var res = []; + for (var idx = 0, len = Opt.size(); idx < len; idx++) { + var item = Opt.lookup(idx); + if (item instanceof PDFString_default || item instanceof PDFHexString_default) { + res.push({ value: item, display: item }); + } + if (item instanceof PDFArray_default) { + if (item.size() > 0) { + var first = item.lookup(0, PDFString_default, PDFHexString_default); + var second = item.lookupMaybe(1, PDFString_default, PDFHexString_default); + res.push({ value: first, display: second || first }); + } + } + } + return res; + } + return []; + }; + return PDFAcroChoice2; + }(PDFAcroTerminal_default) +); +var PDFAcroChoice_default = PDFAcroChoice; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroComboBox.js +var PDFAcroComboBox = ( + /** @class */ + function(_super) { + __extends(PDFAcroComboBox2, _super); + function PDFAcroComboBox2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroComboBox2.fromDict = function(dict, ref) { + return new PDFAcroComboBox2(dict, ref); + }; + PDFAcroComboBox2.create = function(context) { + var dict = context.obj({ + FT: "Ch", + Ff: AcroChoiceFlags.Combo, + Kids: [] + }); + var ref = context.register(dict); + return new PDFAcroComboBox2(dict, ref); + }; + return PDFAcroComboBox2; + }(PDFAcroChoice_default) +); +var PDFAcroComboBox_default = PDFAcroComboBox; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroNonTerminal.js +var PDFAcroNonTerminal = ( + /** @class */ + function(_super) { + __extends(PDFAcroNonTerminal2, _super); + function PDFAcroNonTerminal2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroNonTerminal2.prototype.addField = function(field) { + var Kids = this.normalizedEntries().Kids; + Kids === null || Kids === void 0 ? void 0 : Kids.push(field); + }; + PDFAcroNonTerminal2.prototype.normalizedEntries = function() { + var Kids = this.Kids(); + if (!Kids) { + Kids = this.dict.context.obj([]); + this.dict.set(PDFName_default.of("Kids"), Kids); + } + return { Kids }; + }; + PDFAcroNonTerminal2.fromDict = function(dict, ref) { + return new PDFAcroNonTerminal2(dict, ref); + }; + PDFAcroNonTerminal2.create = function(context) { + var dict = context.obj({}); + var ref = context.register(dict); + return new PDFAcroNonTerminal2(dict, ref); + }; + return PDFAcroNonTerminal2; + }(PDFAcroField_default) +); +var PDFAcroNonTerminal_default = PDFAcroNonTerminal; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroSignature.js +var PDFAcroSignature = ( + /** @class */ + function(_super) { + __extends(PDFAcroSignature2, _super); + function PDFAcroSignature2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroSignature2.fromDict = function(dict, ref) { + return new PDFAcroSignature2(dict, ref); + }; + return PDFAcroSignature2; + }(PDFAcroTerminal_default) +); +var PDFAcroSignature_default = PDFAcroSignature; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroText.js +var PDFAcroText = ( + /** @class */ + function(_super) { + __extends(PDFAcroText2, _super); + function PDFAcroText2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroText2.prototype.MaxLen = function() { + var maxLen = this.dict.lookup(PDFName_default.of("MaxLen")); + if (maxLen instanceof PDFNumber_default) + return maxLen; + return void 0; + }; + PDFAcroText2.prototype.Q = function() { + var q = this.dict.lookup(PDFName_default.of("Q")); + if (q instanceof PDFNumber_default) + return q; + return void 0; + }; + PDFAcroText2.prototype.setMaxLength = function(maxLength) { + this.dict.set(PDFName_default.of("MaxLen"), PDFNumber_default.of(maxLength)); + }; + PDFAcroText2.prototype.removeMaxLength = function() { + this.dict.delete(PDFName_default.of("MaxLen")); + }; + PDFAcroText2.prototype.getMaxLength = function() { + var _a; + return (_a = this.MaxLen()) === null || _a === void 0 ? void 0 : _a.asNumber(); + }; + PDFAcroText2.prototype.setQuadding = function(quadding) { + this.dict.set(PDFName_default.of("Q"), PDFNumber_default.of(quadding)); + }; + PDFAcroText2.prototype.getQuadding = function() { + var _a; + return (_a = this.Q()) === null || _a === void 0 ? void 0 : _a.asNumber(); + }; + PDFAcroText2.prototype.setValue = function(value) { + this.dict.set(PDFName_default.of("V"), value); + }; + PDFAcroText2.prototype.removeValue = function() { + this.dict.delete(PDFName_default.of("V")); + }; + PDFAcroText2.prototype.getValue = function() { + var v = this.V(); + if (v instanceof PDFString_default || v instanceof PDFHexString_default) + return v; + return void 0; + }; + PDFAcroText2.fromDict = function(dict, ref) { + return new PDFAcroText2(dict, ref); + }; + PDFAcroText2.create = function(context) { + var dict = context.obj({ + FT: "Tx", + Kids: [] + }); + var ref = context.register(dict); + return new PDFAcroText2(dict, ref); + }; + return PDFAcroText2; + }(PDFAcroTerminal_default) +); +var PDFAcroText_default = PDFAcroText; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroPushButton.js +var PDFAcroPushButton = ( + /** @class */ + function(_super) { + __extends(PDFAcroPushButton2, _super); + function PDFAcroPushButton2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroPushButton2.fromDict = function(dict, ref) { + return new PDFAcroPushButton2(dict, ref); + }; + PDFAcroPushButton2.create = function(context) { + var dict = context.obj({ + FT: "Btn", + Ff: AcroButtonFlags.PushButton, + Kids: [] + }); + var ref = context.register(dict); + return new PDFAcroPushButton2(dict, ref); + }; + return PDFAcroPushButton2; + }(PDFAcroButton_default) +); +var PDFAcroPushButton_default = PDFAcroPushButton; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroRadioButton.js +var PDFAcroRadioButton = ( + /** @class */ + function(_super) { + __extends(PDFAcroRadioButton2, _super); + function PDFAcroRadioButton2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroRadioButton2.prototype.setValue = function(value) { + var onValues = this.getOnValues(); + if (!onValues.includes(value) && value !== PDFName_default.of("Off")) { + throw new InvalidAcroFieldValueError(); + } + this.dict.set(PDFName_default.of("V"), value); + var widgets = this.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var state = widget.getOnValue() === value ? value : PDFName_default.of("Off"); + widget.setAppearanceState(state); + } + }; + PDFAcroRadioButton2.prototype.getValue = function() { + var v = this.V(); + if (v instanceof PDFName_default) + return v; + return PDFName_default.of("Off"); + }; + PDFAcroRadioButton2.prototype.getOnValues = function() { + var widgets = this.getWidgets(); + var onValues = []; + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var onValue = widgets[idx].getOnValue(); + if (onValue) + onValues.push(onValue); + } + return onValues; + }; + PDFAcroRadioButton2.fromDict = function(dict, ref) { + return new PDFAcroRadioButton2(dict, ref); + }; + PDFAcroRadioButton2.create = function(context) { + var dict = context.obj({ + FT: "Btn", + Ff: AcroButtonFlags.Radio, + Kids: [] + }); + var ref = context.register(dict); + return new PDFAcroRadioButton2(dict, ref); + }; + return PDFAcroRadioButton2; + }(PDFAcroButton_default) +); +var PDFAcroRadioButton_default = PDFAcroRadioButton; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroListBox.js +var PDFAcroListBox = ( + /** @class */ + function(_super) { + __extends(PDFAcroListBox2, _super); + function PDFAcroListBox2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFAcroListBox2.fromDict = function(dict, ref) { + return new PDFAcroListBox2(dict, ref); + }; + PDFAcroListBox2.create = function(context) { + var dict = context.obj({ + FT: "Ch", + Kids: [] + }); + var ref = context.register(dict); + return new PDFAcroListBox2(dict, ref); + }; + return PDFAcroListBox2; + }(PDFAcroChoice_default) +); +var PDFAcroListBox_default = PDFAcroListBox; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/utils.js +var createPDFAcroFields = function(kidDicts) { + if (!kidDicts) + return []; + var kids = []; + for (var idx = 0, len = kidDicts.size(); idx < len; idx++) { + var ref = kidDicts.get(idx); + var dict = kidDicts.lookup(idx); + if (ref instanceof PDFRef_default && dict instanceof PDFDict_default) { + kids.push([createPDFAcroField(dict, ref), ref]); + } + } + return kids; +}; +var createPDFAcroField = function(dict, ref) { + var isNonTerminal = isNonTerminalAcroField(dict); + if (isNonTerminal) + return PDFAcroNonTerminal_default.fromDict(dict, ref); + return createPDFAcroTerminal(dict, ref); +}; +var isNonTerminalAcroField = function(dict) { + var kids = dict.lookup(PDFName_default.of("Kids")); + if (kids instanceof PDFArray_default) { + for (var idx = 0, len = kids.size(); idx < len; idx++) { + var kid = kids.lookup(idx); + var kidIsField = kid instanceof PDFDict_default && kid.has(PDFName_default.of("T")); + if (kidIsField) + return true; + } + } + return false; +}; +var createPDFAcroTerminal = function(dict, ref) { + var ftNameOrRef = getInheritableAttribute(dict, PDFName_default.of("FT")); + var type = dict.context.lookup(ftNameOrRef, PDFName_default); + if (type === PDFName_default.of("Btn")) + return createPDFAcroButton(dict, ref); + if (type === PDFName_default.of("Ch")) + return createPDFAcroChoice(dict, ref); + if (type === PDFName_default.of("Tx")) + return PDFAcroText_default.fromDict(dict, ref); + if (type === PDFName_default.of("Sig")) + return PDFAcroSignature_default.fromDict(dict, ref); + return PDFAcroTerminal_default.fromDict(dict, ref); +}; +var createPDFAcroButton = function(dict, ref) { + var _a; + var ffNumberOrRef = getInheritableAttribute(dict, PDFName_default.of("Ff")); + var ffNumber = dict.context.lookupMaybe(ffNumberOrRef, PDFNumber_default); + var flags = (_a = ffNumber === null || ffNumber === void 0 ? void 0 : ffNumber.asNumber()) !== null && _a !== void 0 ? _a : 0; + if (flagIsSet(flags, AcroButtonFlags.PushButton)) { + return PDFAcroPushButton_default.fromDict(dict, ref); + } else if (flagIsSet(flags, AcroButtonFlags.Radio)) { + return PDFAcroRadioButton_default.fromDict(dict, ref); + } else { + return PDFAcroCheckBox_default.fromDict(dict, ref); + } +}; +var createPDFAcroChoice = function(dict, ref) { + var _a; + var ffNumberOrRef = getInheritableAttribute(dict, PDFName_default.of("Ff")); + var ffNumber = dict.context.lookupMaybe(ffNumberOrRef, PDFNumber_default); + var flags = (_a = ffNumber === null || ffNumber === void 0 ? void 0 : ffNumber.asNumber()) !== null && _a !== void 0 ? _a : 0; + if (flagIsSet(flags, AcroChoiceFlags.Combo)) { + return PDFAcroComboBox_default.fromDict(dict, ref); + } else { + return PDFAcroListBox_default.fromDict(dict, ref); + } +}; +var flagIsSet = function(flags, flag3) { + return (flags & flag3) !== 0; +}; +var getInheritableAttribute = function(startNode, name) { + var attribute; + ascend(startNode, function(node) { + if (!attribute) + attribute = node.get(name); + }); + return attribute; +}; +var ascend = function(startNode, visitor) { + visitor(startNode); + var Parent = startNode.lookupMaybe(PDFName_default.of("Parent"), PDFDict_default); + if (Parent) + ascend(Parent, visitor); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/acroform/PDFAcroForm.js +var PDFAcroForm = ( + /** @class */ + function() { + function PDFAcroForm2(dict) { + this.dict = dict; + } + PDFAcroForm2.prototype.Fields = function() { + var fields = this.dict.lookup(PDFName_default.of("Fields")); + if (fields instanceof PDFArray_default) + return fields; + return void 0; + }; + PDFAcroForm2.prototype.getFields = function() { + var Fields = this.normalizedEntries().Fields; + var fields = new Array(Fields.size()); + for (var idx = 0, len = Fields.size(); idx < len; idx++) { + var ref = Fields.get(idx); + var dict = Fields.lookup(idx, PDFDict_default); + fields[idx] = [createPDFAcroField(dict, ref), ref]; + } + return fields; + }; + PDFAcroForm2.prototype.getAllFields = function() { + var allFields = []; + var pushFields = function(fields) { + if (!fields) + return; + for (var idx = 0, len = fields.length; idx < len; idx++) { + var field = fields[idx]; + allFields.push(field); + var fieldModel = field[0]; + if (fieldModel instanceof PDFAcroNonTerminal_default) { + pushFields(createPDFAcroFields(fieldModel.Kids())); + } + } + }; + pushFields(this.getFields()); + return allFields; + }; + PDFAcroForm2.prototype.addField = function(field) { + var Fields = this.normalizedEntries().Fields; + Fields === null || Fields === void 0 ? void 0 : Fields.push(field); + }; + PDFAcroForm2.prototype.removeField = function(field) { + var parent = field.getParent(); + var fields = parent === void 0 ? this.normalizedEntries().Fields : parent.Kids(); + var index = fields === null || fields === void 0 ? void 0 : fields.indexOf(field.ref); + if (fields === void 0 || index === void 0) { + throw new Error("Tried to remove inexistent field " + field.getFullyQualifiedName()); + } + fields.remove(index); + if (parent !== void 0 && fields.size() === 0) { + this.removeField(parent); + } + }; + PDFAcroForm2.prototype.normalizedEntries = function() { + var Fields = this.Fields(); + if (!Fields) { + Fields = this.dict.context.obj([]); + this.dict.set(PDFName_default.of("Fields"), Fields); + } + return { Fields }; + }; + PDFAcroForm2.fromDict = function(dict) { + return new PDFAcroForm2(dict); + }; + PDFAcroForm2.create = function(context) { + var dict = context.obj({ Fields: [] }); + return new PDFAcroForm2(dict); + }; + return PDFAcroForm2; + }() +); +var PDFAcroForm_default = PDFAcroForm; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFCatalog.js +var PDFCatalog = ( + /** @class */ + function(_super) { + __extends(PDFCatalog2, _super); + function PDFCatalog2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFCatalog2.prototype.Pages = function() { + return this.lookup(PDFName_default.of("Pages"), PDFDict_default); + }; + PDFCatalog2.prototype.AcroForm = function() { + return this.lookupMaybe(PDFName_default.of("AcroForm"), PDFDict_default); + }; + PDFCatalog2.prototype.getAcroForm = function() { + var dict = this.AcroForm(); + if (!dict) + return void 0; + return PDFAcroForm_default.fromDict(dict); + }; + PDFCatalog2.prototype.getOrCreateAcroForm = function() { + var acroForm = this.getAcroForm(); + if (!acroForm) { + acroForm = PDFAcroForm_default.create(this.context); + var acroFormRef = this.context.register(acroForm.dict); + this.set(PDFName_default.of("AcroForm"), acroFormRef); + } + return acroForm; + }; + PDFCatalog2.prototype.ViewerPreferences = function() { + return this.lookupMaybe(PDFName_default.of("ViewerPreferences"), PDFDict_default); + }; + PDFCatalog2.prototype.getViewerPreferences = function() { + var dict = this.ViewerPreferences(); + if (!dict) + return void 0; + return ViewerPreferences_default.fromDict(dict); + }; + PDFCatalog2.prototype.getOrCreateViewerPreferences = function() { + var viewerPrefs = this.getViewerPreferences(); + if (!viewerPrefs) { + viewerPrefs = ViewerPreferences_default.create(this.context); + var viewerPrefsRef = this.context.register(viewerPrefs.dict); + this.set(PDFName_default.of("ViewerPreferences"), viewerPrefsRef); + } + return viewerPrefs; + }; + PDFCatalog2.prototype.insertLeafNode = function(leafRef, index) { + var pagesRef = this.get(PDFName_default.of("Pages")); + var maybeParentRef = this.Pages().insertLeafNode(leafRef, index); + return maybeParentRef || pagesRef; + }; + PDFCatalog2.prototype.removeLeafNode = function(index) { + this.Pages().removeLeafNode(index); + }; + PDFCatalog2.withContextAndPages = function(context, pages) { + var dict = /* @__PURE__ */ new Map(); + dict.set(PDFName_default.of("Type"), PDFName_default.of("Catalog")); + dict.set(PDFName_default.of("Pages"), pages); + return new PDFCatalog2(dict, context); + }; + PDFCatalog2.fromMapWithContext = function(map, context) { + return new PDFCatalog2(map, context); + }; + return PDFCatalog2; + }(PDFDict_default) +); +var PDFCatalog_default = PDFCatalog; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/structures/PDFPageTree.js +var PDFPageTree = ( + /** @class */ + function(_super) { + __extends(PDFPageTree2, _super); + function PDFPageTree2() { + return _super !== null && _super.apply(this, arguments) || this; + } + PDFPageTree2.prototype.Parent = function() { + return this.lookup(PDFName_default.of("Parent")); + }; + PDFPageTree2.prototype.Kids = function() { + return this.lookup(PDFName_default.of("Kids"), PDFArray_default); + }; + PDFPageTree2.prototype.Count = function() { + return this.lookup(PDFName_default.of("Count"), PDFNumber_default); + }; + PDFPageTree2.prototype.pushTreeNode = function(treeRef) { + var Kids = this.Kids(); + Kids.push(treeRef); + }; + PDFPageTree2.prototype.pushLeafNode = function(leafRef) { + var Kids = this.Kids(); + this.insertLeafKid(Kids.size(), leafRef); + }; + PDFPageTree2.prototype.insertLeafNode = function(leafRef, targetIndex) { + var Kids = this.Kids(); + var Count = this.Count().asNumber(); + if (targetIndex > Count) { + throw new InvalidTargetIndexError(targetIndex, Count); + } + var leafsRemainingUntilTarget = targetIndex; + for (var idx = 0, len = Kids.size(); idx < len; idx++) { + if (leafsRemainingUntilTarget === 0) { + this.insertLeafKid(idx, leafRef); + return void 0; + } + var kidRef = Kids.get(idx); + var kid = this.context.lookup(kidRef); + if (kid instanceof PDFPageTree2) { + if (kid.Count().asNumber() > leafsRemainingUntilTarget) { + return kid.insertLeafNode(leafRef, leafsRemainingUntilTarget) || kidRef; + } else { + leafsRemainingUntilTarget -= kid.Count().asNumber(); + } + } + if (kid instanceof PDFPageLeaf_default) { + leafsRemainingUntilTarget -= 1; + } + } + if (leafsRemainingUntilTarget === 0) { + this.insertLeafKid(Kids.size(), leafRef); + return void 0; + } + throw new CorruptPageTreeError(targetIndex, "insertLeafNode"); + }; + PDFPageTree2.prototype.removeLeafNode = function(targetIndex, prune) { + if (prune === void 0) { + prune = true; + } + var Kids = this.Kids(); + var Count = this.Count().asNumber(); + if (targetIndex >= Count) { + throw new InvalidTargetIndexError(targetIndex, Count); + } + var leafsRemainingUntilTarget = targetIndex; + for (var idx = 0, len = Kids.size(); idx < len; idx++) { + var kidRef = Kids.get(idx); + var kid = this.context.lookup(kidRef); + if (kid instanceof PDFPageTree2) { + if (kid.Count().asNumber() > leafsRemainingUntilTarget) { + kid.removeLeafNode(leafsRemainingUntilTarget, prune); + if (prune && kid.Kids().size() === 0) + Kids.remove(idx); + return; + } else { + leafsRemainingUntilTarget -= kid.Count().asNumber(); + } + } + if (kid instanceof PDFPageLeaf_default) { + if (leafsRemainingUntilTarget === 0) { + this.removeKid(idx); + return; + } else { + leafsRemainingUntilTarget -= 1; + } + } + } + throw new CorruptPageTreeError(targetIndex, "removeLeafNode"); + }; + PDFPageTree2.prototype.ascend = function(visitor) { + visitor(this); + var Parent = this.Parent(); + if (Parent) + Parent.ascend(visitor); + }; + PDFPageTree2.prototype.traverse = function(visitor) { + var Kids = this.Kids(); + for (var idx = 0, len = Kids.size(); idx < len; idx++) { + var kidRef = Kids.get(idx); + var kid = this.context.lookup(kidRef); + if (kid instanceof PDFPageTree2) + kid.traverse(visitor); + visitor(kid, kidRef); + } + }; + PDFPageTree2.prototype.insertLeafKid = function(kidIdx, leafRef) { + var Kids = this.Kids(); + this.ascend(function(node) { + var newCount = node.Count().asNumber() + 1; + node.set(PDFName_default.of("Count"), PDFNumber_default.of(newCount)); + }); + Kids.insert(kidIdx, leafRef); + }; + PDFPageTree2.prototype.removeKid = function(kidIdx) { + var Kids = this.Kids(); + var kid = Kids.lookup(kidIdx); + if (kid instanceof PDFPageLeaf_default) { + this.ascend(function(node) { + var newCount = node.Count().asNumber() - 1; + node.set(PDFName_default.of("Count"), PDFNumber_default.of(newCount)); + }); + } + Kids.remove(kidIdx); + }; + PDFPageTree2.withContext = function(context, parent) { + var dict = /* @__PURE__ */ new Map(); + dict.set(PDFName_default.of("Type"), PDFName_default.of("Pages")); + dict.set(PDFName_default.of("Kids"), context.obj([])); + dict.set(PDFName_default.of("Count"), context.obj(0)); + if (parent) + dict.set(PDFName_default.of("Parent"), parent); + return new PDFPageTree2(dict, context); + }; + PDFPageTree2.fromMapWithContext = function(map, context) { + return new PDFPageTree2(map, context); + }; + return PDFPageTree2; + }(PDFDict_default) +); +var PDFPageTree_default = PDFPageTree; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/syntax/Numeric.js +var IsDigit = new Uint8Array(256); +IsDigit[CharCodes_default.Zero] = 1; +IsDigit[CharCodes_default.One] = 1; +IsDigit[CharCodes_default.Two] = 1; +IsDigit[CharCodes_default.Three] = 1; +IsDigit[CharCodes_default.Four] = 1; +IsDigit[CharCodes_default.Five] = 1; +IsDigit[CharCodes_default.Six] = 1; +IsDigit[CharCodes_default.Seven] = 1; +IsDigit[CharCodes_default.Eight] = 1; +IsDigit[CharCodes_default.Nine] = 1; +var IsNumericPrefix = new Uint8Array(256); +IsNumericPrefix[CharCodes_default.Period] = 1; +IsNumericPrefix[CharCodes_default.Plus] = 1; +IsNumericPrefix[CharCodes_default.Minus] = 1; +var IsNumeric = new Uint8Array(256); +for (idx = 0, len = 256; idx < len; idx++) { + IsNumeric[idx] = IsDigit[idx] || IsNumericPrefix[idx] ? 1 : 0; +} +var idx; +var len; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/parser/BaseParser.js +var Newline = CharCodes_default.Newline; +var CarriageReturn = CharCodes_default.CarriageReturn; +var BaseParser = ( + /** @class */ + function() { + function BaseParser2(bytes, capNumbers) { + if (capNumbers === void 0) { + capNumbers = false; + } + this.bytes = bytes; + this.capNumbers = capNumbers; + } + BaseParser2.prototype.parseRawInt = function() { + var value = ""; + while (!this.bytes.done()) { + var byte = this.bytes.peek(); + if (!IsDigit[byte]) + break; + value += charFromCode(this.bytes.next()); + } + var numberValue = Number(value); + if (!value || !isFinite(numberValue)) { + throw new NumberParsingError(this.bytes.position(), value); + } + return numberValue; + }; + BaseParser2.prototype.parseRawNumber = function() { + var value = ""; + while (!this.bytes.done()) { + var byte = this.bytes.peek(); + if (!IsNumeric[byte]) + break; + value += charFromCode(this.bytes.next()); + if (byte === CharCodes_default.Period) + break; + } + while (!this.bytes.done()) { + var byte = this.bytes.peek(); + if (!IsDigit[byte]) + break; + value += charFromCode(this.bytes.next()); + } + var numberValue = Number(value); + if (!value || !isFinite(numberValue)) { + throw new NumberParsingError(this.bytes.position(), value); + } + if (numberValue > Number.MAX_SAFE_INTEGER) { + if (this.capNumbers) { + var msg = "Parsed number that is too large for some PDF readers: " + value + ", using Number.MAX_SAFE_INTEGER instead."; + console.warn(msg); + return Number.MAX_SAFE_INTEGER; + } else { + var msg = "Parsed number that is too large for some PDF readers: " + value + ", not capping."; + console.warn(msg); + } + } + return numberValue; + }; + BaseParser2.prototype.skipWhitespace = function() { + while (!this.bytes.done() && IsWhitespace[this.bytes.peek()]) { + this.bytes.next(); + } + }; + BaseParser2.prototype.skipLine = function() { + while (!this.bytes.done()) { + var byte = this.bytes.peek(); + if (byte === Newline || byte === CarriageReturn) + return; + this.bytes.next(); + } + }; + BaseParser2.prototype.skipComment = function() { + if (this.bytes.peek() !== CharCodes_default.Percent) + return false; + while (!this.bytes.done()) { + var byte = this.bytes.peek(); + if (byte === Newline || byte === CarriageReturn) + return true; + this.bytes.next(); + } + return true; + }; + BaseParser2.prototype.skipWhitespaceAndComments = function() { + this.skipWhitespace(); + while (this.skipComment()) + this.skipWhitespace(); + }; + BaseParser2.prototype.matchKeyword = function(keyword) { + var initialOffset = this.bytes.offset(); + for (var idx = 0, len = keyword.length; idx < len; idx++) { + if (this.bytes.done() || this.bytes.next() !== keyword[idx]) { + this.bytes.moveTo(initialOffset); + return false; + } + } + return true; + }; + return BaseParser2; + }() +); +var BaseParser_default = BaseParser; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/parser/ByteStream.js +var ByteStream = ( + /** @class */ + function() { + function ByteStream2(bytes) { + this.idx = 0; + this.line = 0; + this.column = 0; + this.bytes = bytes; + this.length = this.bytes.length; + } + ByteStream2.prototype.moveTo = function(offset) { + this.idx = offset; + }; + ByteStream2.prototype.next = function() { + var byte = this.bytes[this.idx++]; + if (byte === CharCodes_default.Newline) { + this.line += 1; + this.column = 0; + } else { + this.column += 1; + } + return byte; + }; + ByteStream2.prototype.assertNext = function(expected) { + if (this.peek() !== expected) { + throw new NextByteAssertionError(this.position(), expected, this.peek()); + } + return this.next(); + }; + ByteStream2.prototype.peek = function() { + return this.bytes[this.idx]; + }; + ByteStream2.prototype.peekAhead = function(steps) { + return this.bytes[this.idx + steps]; + }; + ByteStream2.prototype.peekAt = function(offset) { + return this.bytes[offset]; + }; + ByteStream2.prototype.done = function() { + return this.idx >= this.length; + }; + ByteStream2.prototype.offset = function() { + return this.idx; + }; + ByteStream2.prototype.slice = function(start, end) { + return this.bytes.slice(start, end); + }; + ByteStream2.prototype.position = function() { + return { line: this.line, column: this.column, offset: this.idx }; + }; + ByteStream2.of = function(bytes) { + return new ByteStream2(bytes); + }; + ByteStream2.fromPDFRawStream = function(rawStream) { + return ByteStream2.of(decodePDFRawStream(rawStream).decode()); + }; + return ByteStream2; + }() +); +var ByteStream_default = ByteStream; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/syntax/Keywords.js +var Space = CharCodes_default.Space; +var CarriageReturn2 = CharCodes_default.CarriageReturn; +var Newline2 = CharCodes_default.Newline; +var stream = [ + CharCodes_default.s, + CharCodes_default.t, + CharCodes_default.r, + CharCodes_default.e, + CharCodes_default.a, + CharCodes_default.m +]; +var endstream = [ + CharCodes_default.e, + CharCodes_default.n, + CharCodes_default.d, + CharCodes_default.s, + CharCodes_default.t, + CharCodes_default.r, + CharCodes_default.e, + CharCodes_default.a, + CharCodes_default.m +]; +var Keywords = { + header: [ + CharCodes_default.Percent, + CharCodes_default.P, + CharCodes_default.D, + CharCodes_default.F, + CharCodes_default.Dash + ], + eof: [ + CharCodes_default.Percent, + CharCodes_default.Percent, + CharCodes_default.E, + CharCodes_default.O, + CharCodes_default.F + ], + obj: [CharCodes_default.o, CharCodes_default.b, CharCodes_default.j], + endobj: [ + CharCodes_default.e, + CharCodes_default.n, + CharCodes_default.d, + CharCodes_default.o, + CharCodes_default.b, + CharCodes_default.j + ], + xref: [CharCodes_default.x, CharCodes_default.r, CharCodes_default.e, CharCodes_default.f], + trailer: [ + CharCodes_default.t, + CharCodes_default.r, + CharCodes_default.a, + CharCodes_default.i, + CharCodes_default.l, + CharCodes_default.e, + CharCodes_default.r + ], + startxref: [ + CharCodes_default.s, + CharCodes_default.t, + CharCodes_default.a, + CharCodes_default.r, + CharCodes_default.t, + CharCodes_default.x, + CharCodes_default.r, + CharCodes_default.e, + CharCodes_default.f + ], + true: [CharCodes_default.t, CharCodes_default.r, CharCodes_default.u, CharCodes_default.e], + false: [CharCodes_default.f, CharCodes_default.a, CharCodes_default.l, CharCodes_default.s, CharCodes_default.e], + null: [CharCodes_default.n, CharCodes_default.u, CharCodes_default.l, CharCodes_default.l], + stream, + streamEOF1: __spreadArrays(stream, [Space, CarriageReturn2, Newline2]), + streamEOF2: __spreadArrays(stream, [CarriageReturn2, Newline2]), + streamEOF3: __spreadArrays(stream, [CarriageReturn2]), + streamEOF4: __spreadArrays(stream, [Newline2]), + endstream, + EOF1endstream: __spreadArrays([CarriageReturn2, Newline2], endstream), + EOF2endstream: __spreadArrays([CarriageReturn2], endstream), + EOF3endstream: __spreadArrays([Newline2], endstream) +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/parser/PDFObjectParser.js +var PDFObjectParser = ( + /** @class */ + function(_super) { + __extends(PDFObjectParser2, _super); + function PDFObjectParser2(byteStream, context, capNumbers) { + if (capNumbers === void 0) { + capNumbers = false; + } + var _this = _super.call(this, byteStream, capNumbers) || this; + _this.context = context; + return _this; + } + PDFObjectParser2.prototype.parseObject = function() { + this.skipWhitespaceAndComments(); + if (this.matchKeyword(Keywords.true)) + return PDFBool_default.True; + if (this.matchKeyword(Keywords.false)) + return PDFBool_default.False; + if (this.matchKeyword(Keywords.null)) + return PDFNull_default; + var byte = this.bytes.peek(); + if (byte === CharCodes_default.LessThan && this.bytes.peekAhead(1) === CharCodes_default.LessThan) { + return this.parseDictOrStream(); + } + if (byte === CharCodes_default.LessThan) + return this.parseHexString(); + if (byte === CharCodes_default.LeftParen) + return this.parseString(); + if (byte === CharCodes_default.ForwardSlash) + return this.parseName(); + if (byte === CharCodes_default.LeftSquareBracket) + return this.parseArray(); + if (IsNumeric[byte]) + return this.parseNumberOrRef(); + throw new PDFObjectParsingError(this.bytes.position(), byte); + }; + PDFObjectParser2.prototype.parseNumberOrRef = function() { + var firstNum = this.parseRawNumber(); + this.skipWhitespaceAndComments(); + var lookaheadStart = this.bytes.offset(); + if (IsDigit[this.bytes.peek()]) { + var secondNum = this.parseRawNumber(); + this.skipWhitespaceAndComments(); + if (this.bytes.peek() === CharCodes_default.R) { + this.bytes.assertNext(CharCodes_default.R); + return PDFRef_default.of(firstNum, secondNum); + } + } + this.bytes.moveTo(lookaheadStart); + return PDFNumber_default.of(firstNum); + }; + PDFObjectParser2.prototype.parseHexString = function() { + var value = ""; + this.bytes.assertNext(CharCodes_default.LessThan); + while (!this.bytes.done() && this.bytes.peek() !== CharCodes_default.GreaterThan) { + value += charFromCode(this.bytes.next()); + } + this.bytes.assertNext(CharCodes_default.GreaterThan); + return PDFHexString_default.of(value); + }; + PDFObjectParser2.prototype.parseString = function() { + var nestingLvl = 0; + var isEscaped = false; + var value = ""; + while (!this.bytes.done()) { + var byte = this.bytes.next(); + value += charFromCode(byte); + if (!isEscaped) { + if (byte === CharCodes_default.LeftParen) + nestingLvl += 1; + if (byte === CharCodes_default.RightParen) + nestingLvl -= 1; + } + if (byte === CharCodes_default.BackSlash) { + isEscaped = !isEscaped; + } else if (isEscaped) { + isEscaped = false; + } + if (nestingLvl === 0) { + return PDFString_default.of(value.substring(1, value.length - 1)); + } + } + throw new UnbalancedParenthesisError(this.bytes.position()); + }; + PDFObjectParser2.prototype.parseName = function() { + this.bytes.assertNext(CharCodes_default.ForwardSlash); + var name = ""; + while (!this.bytes.done()) { + var byte = this.bytes.peek(); + if (IsWhitespace[byte] || IsDelimiter[byte]) + break; + name += charFromCode(byte); + this.bytes.next(); + } + return PDFName_default.of(name); + }; + PDFObjectParser2.prototype.parseArray = function() { + this.bytes.assertNext(CharCodes_default.LeftSquareBracket); + this.skipWhitespaceAndComments(); + var pdfArray = PDFArray_default.withContext(this.context); + while (this.bytes.peek() !== CharCodes_default.RightSquareBracket) { + var element = this.parseObject(); + pdfArray.push(element); + this.skipWhitespaceAndComments(); + } + this.bytes.assertNext(CharCodes_default.RightSquareBracket); + return pdfArray; + }; + PDFObjectParser2.prototype.parseDict = function() { + this.bytes.assertNext(CharCodes_default.LessThan); + this.bytes.assertNext(CharCodes_default.LessThan); + this.skipWhitespaceAndComments(); + var dict = /* @__PURE__ */ new Map(); + while (!this.bytes.done() && this.bytes.peek() !== CharCodes_default.GreaterThan && this.bytes.peekAhead(1) !== CharCodes_default.GreaterThan) { + var key = this.parseName(); + var value = this.parseObject(); + dict.set(key, value); + this.skipWhitespaceAndComments(); + } + this.skipWhitespaceAndComments(); + this.bytes.assertNext(CharCodes_default.GreaterThan); + this.bytes.assertNext(CharCodes_default.GreaterThan); + var Type = dict.get(PDFName_default.of("Type")); + if (Type === PDFName_default.of("Catalog")) { + return PDFCatalog_default.fromMapWithContext(dict, this.context); + } else if (Type === PDFName_default.of("Pages")) { + return PDFPageTree_default.fromMapWithContext(dict, this.context); + } else if (Type === PDFName_default.of("Page")) { + return PDFPageLeaf_default.fromMapWithContext(dict, this.context); + } else { + return PDFDict_default.fromMapWithContext(dict, this.context); + } + }; + PDFObjectParser2.prototype.parseDictOrStream = function() { + var startPos = this.bytes.position(); + var dict = this.parseDict(); + this.skipWhitespaceAndComments(); + if (!this.matchKeyword(Keywords.streamEOF1) && !this.matchKeyword(Keywords.streamEOF2) && !this.matchKeyword(Keywords.streamEOF3) && !this.matchKeyword(Keywords.streamEOF4) && !this.matchKeyword(Keywords.stream)) { + return dict; + } + var start = this.bytes.offset(); + var end; + var Length = dict.get(PDFName_default.of("Length")); + if (Length instanceof PDFNumber_default) { + end = start + Length.asNumber(); + this.bytes.moveTo(end); + this.skipWhitespaceAndComments(); + if (!this.matchKeyword(Keywords.endstream)) { + this.bytes.moveTo(start); + end = this.findEndOfStreamFallback(startPos); + } + } else { + end = this.findEndOfStreamFallback(startPos); + } + var contents = this.bytes.slice(start, end); + return PDFRawStream_default.of(dict, contents); + }; + PDFObjectParser2.prototype.findEndOfStreamFallback = function(startPos) { + var nestingLvl = 1; + var end = this.bytes.offset(); + while (!this.bytes.done()) { + end = this.bytes.offset(); + if (this.matchKeyword(Keywords.stream)) { + nestingLvl += 1; + } else if (this.matchKeyword(Keywords.EOF1endstream) || this.matchKeyword(Keywords.EOF2endstream) || this.matchKeyword(Keywords.EOF3endstream) || this.matchKeyword(Keywords.endstream)) { + nestingLvl -= 1; + } else { + this.bytes.next(); + } + if (nestingLvl === 0) + break; + } + if (nestingLvl !== 0) + throw new PDFStreamParsingError(startPos); + return end; + }; + PDFObjectParser2.forBytes = function(bytes, context, capNumbers) { + return new PDFObjectParser2(ByteStream_default.of(bytes), context, capNumbers); + }; + PDFObjectParser2.forByteStream = function(byteStream, context, capNumbers) { + if (capNumbers === void 0) { + capNumbers = false; + } + return new PDFObjectParser2(byteStream, context, capNumbers); + }; + return PDFObjectParser2; + }(BaseParser_default) +); +var PDFObjectParser_default = PDFObjectParser; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/parser/PDFObjectStreamParser.js +var PDFObjectStreamParser = ( + /** @class */ + function(_super) { + __extends(PDFObjectStreamParser2, _super); + function PDFObjectStreamParser2(rawStream, shouldWaitForTick) { + var _this = _super.call(this, ByteStream_default.fromPDFRawStream(rawStream), rawStream.dict.context) || this; + var dict = rawStream.dict; + _this.alreadyParsed = false; + _this.shouldWaitForTick = shouldWaitForTick || function() { + return false; + }; + _this.firstOffset = dict.lookup(PDFName_default.of("First"), PDFNumber_default).asNumber(); + _this.objectCount = dict.lookup(PDFName_default.of("N"), PDFNumber_default).asNumber(); + return _this; + } + PDFObjectStreamParser2.prototype.parseIntoContext = function() { + return __awaiter(this, void 0, void 0, function() { + var offsetsAndObjectNumbers, idx, len, _a, objectNumber, offset, object, ref; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + if (this.alreadyParsed) { + throw new ReparseError("PDFObjectStreamParser", "parseIntoContext"); + } + this.alreadyParsed = true; + offsetsAndObjectNumbers = this.parseOffsetsAndObjectNumbers(); + idx = 0, len = offsetsAndObjectNumbers.length; + _b.label = 1; + case 1: + if (!(idx < len)) return [3, 4]; + _a = offsetsAndObjectNumbers[idx], objectNumber = _a.objectNumber, offset = _a.offset; + this.bytes.moveTo(this.firstOffset + offset); + object = this.parseObject(); + ref = PDFRef_default.of(objectNumber, 0); + this.context.assign(ref, object); + if (!this.shouldWaitForTick()) return [3, 3]; + return [4, waitForTick()]; + case 2: + _b.sent(); + _b.label = 3; + case 3: + idx++; + return [3, 1]; + case 4: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFObjectStreamParser2.prototype.parseOffsetsAndObjectNumbers = function() { + var offsetsAndObjectNumbers = []; + for (var idx = 0, len = this.objectCount; idx < len; idx++) { + this.skipWhitespaceAndComments(); + var objectNumber = this.parseRawInt(); + this.skipWhitespaceAndComments(); + var offset = this.parseRawInt(); + offsetsAndObjectNumbers.push({ objectNumber, offset }); + } + return offsetsAndObjectNumbers; + }; + PDFObjectStreamParser2.forStream = function(rawStream, shouldWaitForTick) { + return new PDFObjectStreamParser2(rawStream, shouldWaitForTick); + }; + return PDFObjectStreamParser2; + }(PDFObjectParser_default) +); +var PDFObjectStreamParser_default = PDFObjectStreamParser; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/parser/PDFXRefStreamParser.js +var PDFXRefStreamParser = ( + /** @class */ + function() { + function PDFXRefStreamParser2(rawStream) { + this.alreadyParsed = false; + this.dict = rawStream.dict; + this.bytes = ByteStream_default.fromPDFRawStream(rawStream); + this.context = this.dict.context; + var Size = this.dict.lookup(PDFName_default.of("Size"), PDFNumber_default); + var Index = this.dict.lookup(PDFName_default.of("Index")); + if (Index instanceof PDFArray_default) { + this.subsections = []; + for (var idx = 0, len = Index.size(); idx < len; idx += 2) { + var firstObjectNumber = Index.lookup(idx + 0, PDFNumber_default).asNumber(); + var length_1 = Index.lookup(idx + 1, PDFNumber_default).asNumber(); + this.subsections.push({ firstObjectNumber, length: length_1 }); + } + } else { + this.subsections = [{ firstObjectNumber: 0, length: Size.asNumber() }]; + } + var W = this.dict.lookup(PDFName_default.of("W"), PDFArray_default); + this.byteWidths = [-1, -1, -1]; + for (var idx = 0, len = W.size(); idx < len; idx++) { + this.byteWidths[idx] = W.lookup(idx, PDFNumber_default).asNumber(); + } + } + PDFXRefStreamParser2.prototype.parseIntoContext = function() { + if (this.alreadyParsed) { + throw new ReparseError("PDFXRefStreamParser", "parseIntoContext"); + } + this.alreadyParsed = true; + this.context.trailerInfo = { + Root: this.dict.get(PDFName_default.of("Root")), + Encrypt: this.dict.get(PDFName_default.of("Encrypt")), + Info: this.dict.get(PDFName_default.of("Info")), + ID: this.dict.get(PDFName_default.of("ID")) + }; + var entries = this.parseEntries(); + return entries; + }; + PDFXRefStreamParser2.prototype.parseEntries = function() { + var entries = []; + var _a = this.byteWidths, typeFieldWidth = _a[0], offsetFieldWidth = _a[1], genFieldWidth = _a[2]; + for (var subsectionIdx = 0, subsectionLen = this.subsections.length; subsectionIdx < subsectionLen; subsectionIdx++) { + var _b = this.subsections[subsectionIdx], firstObjectNumber = _b.firstObjectNumber, length_2 = _b.length; + for (var objIdx = 0; objIdx < length_2; objIdx++) { + var type = 0; + for (var idx = 0, len = typeFieldWidth; idx < len; idx++) { + type = type << 8 | this.bytes.next(); + } + var offset = 0; + for (var idx = 0, len = offsetFieldWidth; idx < len; idx++) { + offset = offset << 8 | this.bytes.next(); + } + var generationNumber = 0; + for (var idx = 0, len = genFieldWidth; idx < len; idx++) { + generationNumber = generationNumber << 8 | this.bytes.next(); + } + if (typeFieldWidth === 0) + type = 1; + var objectNumber = firstObjectNumber + objIdx; + var entry = { + ref: PDFRef_default.of(objectNumber, generationNumber), + offset, + deleted: type === 0, + inObjectStream: type === 2 + }; + entries.push(entry); + } + } + return entries; + }; + PDFXRefStreamParser2.forStream = function(rawStream) { + return new PDFXRefStreamParser2(rawStream); + }; + return PDFXRefStreamParser2; + }() +); +var PDFXRefStreamParser_default = PDFXRefStreamParser; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/parser/PDFParser.js +var PDFParser = ( + /** @class */ + function(_super) { + __extends(PDFParser2, _super); + function PDFParser2(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers) { + if (objectsPerTick === void 0) { + objectsPerTick = Infinity; + } + if (throwOnInvalidObject === void 0) { + throwOnInvalidObject = false; + } + if (capNumbers === void 0) { + capNumbers = false; + } + var _this = _super.call(this, ByteStream_default.of(pdfBytes), PDFContext_default.create(), capNumbers) || this; + _this.alreadyParsed = false; + _this.parsedObjects = 0; + _this.shouldWaitForTick = function() { + _this.parsedObjects += 1; + return _this.parsedObjects % _this.objectsPerTick === 0; + }; + _this.objectsPerTick = objectsPerTick; + _this.throwOnInvalidObject = throwOnInvalidObject; + return _this; + } + PDFParser2.prototype.parseDocument = function() { + return __awaiter(this, void 0, void 0, function() { + var prevOffset, offset; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + if (this.alreadyParsed) { + throw new ReparseError("PDFParser", "parseDocument"); + } + this.alreadyParsed = true; + this.context.header = this.parseHeader(); + _a.label = 1; + case 1: + if (!!this.bytes.done()) return [3, 3]; + return [4, this.parseDocumentSection()]; + case 2: + _a.sent(); + offset = this.bytes.offset(); + if (offset === prevOffset) { + throw new StalledParserError(this.bytes.position()); + } + prevOffset = offset; + return [3, 1]; + case 3: + this.maybeRecoverRoot(); + if (this.context.lookup(PDFRef_default.of(0))) { + console.warn("Removing parsed object: 0 0 R"); + this.context.delete(PDFRef_default.of(0)); + } + return [2, this.context]; + } + }); + }); + }; + PDFParser2.prototype.maybeRecoverRoot = function() { + var isValidCatalog = function(obj) { + return obj instanceof PDFDict_default && obj.lookup(PDFName_default.of("Type")) === PDFName_default.of("Catalog"); + }; + var catalog = this.context.lookup(this.context.trailerInfo.Root); + if (!isValidCatalog(catalog)) { + var indirectObjects = this.context.enumerateIndirectObjects(); + for (var idx = 0, len = indirectObjects.length; idx < len; idx++) { + var _a = indirectObjects[idx], ref = _a[0], object = _a[1]; + if (isValidCatalog(object)) { + this.context.trailerInfo.Root = ref; + } + } + } + }; + PDFParser2.prototype.parseHeader = function() { + while (!this.bytes.done()) { + if (this.matchKeyword(Keywords.header)) { + var major = this.parseRawInt(); + this.bytes.assertNext(CharCodes_default.Period); + var minor = this.parseRawInt(); + var header = PDFHeader_default.forVersion(major, minor); + this.skipBinaryHeaderComment(); + return header; + } + this.bytes.next(); + } + throw new MissingPDFHeaderError(this.bytes.position()); + }; + PDFParser2.prototype.parseIndirectObjectHeader = function() { + this.skipWhitespaceAndComments(); + var objectNumber = this.parseRawInt(); + this.skipWhitespaceAndComments(); + var generationNumber = this.parseRawInt(); + this.skipWhitespaceAndComments(); + if (!this.matchKeyword(Keywords.obj)) { + throw new MissingKeywordError(this.bytes.position(), Keywords.obj); + } + return PDFRef_default.of(objectNumber, generationNumber); + }; + PDFParser2.prototype.matchIndirectObjectHeader = function() { + var initialOffset = this.bytes.offset(); + try { + this.parseIndirectObjectHeader(); + return true; + } catch (e) { + this.bytes.moveTo(initialOffset); + return false; + } + }; + PDFParser2.prototype.parseIndirectObject = function() { + return __awaiter(this, void 0, void 0, function() { + var ref, object; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + ref = this.parseIndirectObjectHeader(); + this.skipWhitespaceAndComments(); + object = this.parseObject(); + this.skipWhitespaceAndComments(); + this.matchKeyword(Keywords.endobj); + if (!(object instanceof PDFRawStream_default && object.dict.lookup(PDFName_default.of("Type")) === PDFName_default.of("ObjStm"))) return [3, 2]; + return [4, PDFObjectStreamParser_default.forStream(object, this.shouldWaitForTick).parseIntoContext()]; + case 1: + _a.sent(); + return [3, 3]; + case 2: + if (object instanceof PDFRawStream_default && object.dict.lookup(PDFName_default.of("Type")) === PDFName_default.of("XRef")) { + PDFXRefStreamParser_default.forStream(object).parseIntoContext(); + } else { + this.context.assign(ref, object); + } + _a.label = 3; + case 3: + return [2, ref]; + } + }); + }); + }; + PDFParser2.prototype.tryToParseInvalidIndirectObject = function() { + var startPos = this.bytes.position(); + var msg = "Trying to parse invalid object: " + JSON.stringify(startPos) + ")"; + if (this.throwOnInvalidObject) + throw new Error(msg); + console.warn(msg); + var ref = this.parseIndirectObjectHeader(); + console.warn("Invalid object ref: " + ref); + this.skipWhitespaceAndComments(); + var start = this.bytes.offset(); + var failed = true; + while (!this.bytes.done()) { + if (this.matchKeyword(Keywords.endobj)) { + failed = false; + } + if (!failed) + break; + this.bytes.next(); + } + if (failed) + throw new PDFInvalidObjectParsingError(startPos); + var end = this.bytes.offset() - Keywords.endobj.length; + var object = PDFInvalidObject_default.of(this.bytes.slice(start, end)); + this.context.assign(ref, object); + return ref; + }; + PDFParser2.prototype.parseIndirectObjects = function() { + return __awaiter(this, void 0, void 0, function() { + var initialOffset, e_1; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + this.skipWhitespaceAndComments(); + _a.label = 1; + case 1: + if (!(!this.bytes.done() && IsDigit[this.bytes.peek()])) return [3, 8]; + initialOffset = this.bytes.offset(); + _a.label = 2; + case 2: + _a.trys.push([2, 4, , 5]); + return [4, this.parseIndirectObject()]; + case 3: + _a.sent(); + return [3, 5]; + case 4: + e_1 = _a.sent(); + this.bytes.moveTo(initialOffset); + this.tryToParseInvalidIndirectObject(); + return [3, 5]; + case 5: + this.skipWhitespaceAndComments(); + this.skipJibberish(); + if (!this.shouldWaitForTick()) return [3, 7]; + return [4, waitForTick()]; + case 6: + _a.sent(); + _a.label = 7; + case 7: + return [3, 1]; + case 8: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFParser2.prototype.maybeParseCrossRefSection = function() { + this.skipWhitespaceAndComments(); + if (!this.matchKeyword(Keywords.xref)) + return; + this.skipWhitespaceAndComments(); + var objectNumber = -1; + var xref = PDFCrossRefSection_default.createEmpty(); + while (!this.bytes.done() && IsDigit[this.bytes.peek()]) { + var firstInt = this.parseRawInt(); + this.skipWhitespaceAndComments(); + var secondInt = this.parseRawInt(); + this.skipWhitespaceAndComments(); + var byte = this.bytes.peek(); + if (byte === CharCodes_default.n || byte === CharCodes_default.f) { + var ref = PDFRef_default.of(objectNumber, secondInt); + if (this.bytes.next() === CharCodes_default.n) { + xref.addEntry(ref, firstInt); + } else { + xref.addDeletedEntry(ref, firstInt); + } + objectNumber += 1; + } else { + objectNumber = firstInt; + } + this.skipWhitespaceAndComments(); + } + return xref; + }; + PDFParser2.prototype.maybeParseTrailerDict = function() { + this.skipWhitespaceAndComments(); + if (!this.matchKeyword(Keywords.trailer)) + return; + this.skipWhitespaceAndComments(); + var dict = this.parseDict(); + var context = this.context; + context.trailerInfo = { + Root: dict.get(PDFName_default.of("Root")) || context.trailerInfo.Root, + Encrypt: dict.get(PDFName_default.of("Encrypt")) || context.trailerInfo.Encrypt, + Info: dict.get(PDFName_default.of("Info")) || context.trailerInfo.Info, + ID: dict.get(PDFName_default.of("ID")) || context.trailerInfo.ID + }; + }; + PDFParser2.prototype.maybeParseTrailer = function() { + this.skipWhitespaceAndComments(); + if (!this.matchKeyword(Keywords.startxref)) + return; + this.skipWhitespaceAndComments(); + var offset = this.parseRawInt(); + this.skipWhitespace(); + this.matchKeyword(Keywords.eof); + this.skipWhitespaceAndComments(); + this.matchKeyword(Keywords.eof); + this.skipWhitespaceAndComments(); + return PDFTrailer_default.forLastCrossRefSectionOffset(offset); + }; + PDFParser2.prototype.parseDocumentSection = function() { + return __awaiter(this, void 0, void 0, function() { + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, this.parseIndirectObjects()]; + case 1: + _a.sent(); + this.maybeParseCrossRefSection(); + this.maybeParseTrailerDict(); + this.maybeParseTrailer(); + this.skipJibberish(); + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFParser2.prototype.skipJibberish = function() { + this.skipWhitespaceAndComments(); + while (!this.bytes.done()) { + var initialOffset = this.bytes.offset(); + var byte = this.bytes.peek(); + var isAlphaNumeric = byte >= CharCodes_default.Space && byte <= CharCodes_default.Tilde; + if (isAlphaNumeric) { + if (this.matchKeyword(Keywords.xref) || this.matchKeyword(Keywords.trailer) || this.matchKeyword(Keywords.startxref) || this.matchIndirectObjectHeader()) { + this.bytes.moveTo(initialOffset); + break; + } + } + this.bytes.next(); + } + }; + PDFParser2.prototype.skipBinaryHeaderComment = function() { + this.skipWhitespaceAndComments(); + try { + var initialOffset = this.bytes.offset(); + this.parseIndirectObjectHeader(); + this.bytes.moveTo(initialOffset); + } catch (e) { + this.bytes.next(); + this.skipWhitespaceAndComments(); + } + }; + PDFParser2.forBytesWithOptions = function(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers) { + return new PDFParser2(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers); + }; + return PDFParser2; + }(PDFObjectParser_default) +); +var PDFParser_default = PDFParser; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/annotation/flags.js +var flag2 = function(bitIndex) { + return 1 << bitIndex; +}; +var AnnotationFlags; +(function(AnnotationFlags2) { + AnnotationFlags2[AnnotationFlags2["Invisible"] = flag2(1 - 1)] = "Invisible"; + AnnotationFlags2[AnnotationFlags2["Hidden"] = flag2(2 - 1)] = "Hidden"; + AnnotationFlags2[AnnotationFlags2["Print"] = flag2(3 - 1)] = "Print"; + AnnotationFlags2[AnnotationFlags2["NoZoom"] = flag2(4 - 1)] = "NoZoom"; + AnnotationFlags2[AnnotationFlags2["NoRotate"] = flag2(5 - 1)] = "NoRotate"; + AnnotationFlags2[AnnotationFlags2["NoView"] = flag2(6 - 1)] = "NoView"; + AnnotationFlags2[AnnotationFlags2["ReadOnly"] = flag2(7 - 1)] = "ReadOnly"; + AnnotationFlags2[AnnotationFlags2["Locked"] = flag2(8 - 1)] = "Locked"; + AnnotationFlags2[AnnotationFlags2["ToggleNoView"] = flag2(9 - 1)] = "ToggleNoView"; + AnnotationFlags2[AnnotationFlags2["LockedContents"] = flag2(10 - 1)] = "LockedContents"; +})(AnnotationFlags || (AnnotationFlags = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/objects.js +var asPDFName = function(name) { + return name instanceof PDFName_default ? name : PDFName_default.of(name); +}; +var asPDFNumber = function(num) { + return num instanceof PDFNumber_default ? num : PDFNumber_default.of(num); +}; +var asNumber = function(num) { + return num instanceof PDFNumber_default ? num.asNumber() : num; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/rotations.js +var RotationTypes; +(function(RotationTypes2) { + RotationTypes2["Degrees"] = "degrees"; + RotationTypes2["Radians"] = "radians"; +})(RotationTypes || (RotationTypes = {})); +var degrees = function(degreeAngle) { + assertIs(degreeAngle, "degreeAngle", ["number"]); + return { type: RotationTypes.Degrees, angle: degreeAngle }; +}; +var Radians = RotationTypes.Radians; +var Degrees = RotationTypes.Degrees; +var degreesToRadians = function(degree) { + return degree * Math.PI / 180; +}; +var radiansToDegrees = function(radian) { + return radian * 180 / Math.PI; +}; +var toRadians = function(rotation) { + return rotation.type === Radians ? rotation.angle : rotation.type === Degrees ? degreesToRadians(rotation.angle) : error("Invalid rotation: " + JSON.stringify(rotation)); +}; +var toDegrees = function(rotation) { + return rotation.type === Radians ? radiansToDegrees(rotation.angle) : rotation.type === Degrees ? rotation.angle : error("Invalid rotation: " + JSON.stringify(rotation)); +}; +var reduceRotation = function(degreeAngle) { + if (degreeAngle === void 0) { + degreeAngle = 0; + } + var quadrants = degreeAngle / 90 % 4; + if (quadrants === 0) + return 0; + if (quadrants === 1) + return 90; + if (quadrants === 2) + return 180; + if (quadrants === 3) + return 270; + return 0; +}; +var adjustDimsForRotation = function(dims, degreeAngle) { + if (degreeAngle === void 0) { + degreeAngle = 0; + } + var rotation = reduceRotation(degreeAngle); + return rotation === 90 || rotation === 270 ? { width: dims.height, height: dims.width } : { width: dims.width, height: dims.height }; +}; +var rotateRectangle = function(rectangle, borderWidth, degreeAngle) { + if (borderWidth === void 0) { + borderWidth = 0; + } + if (degreeAngle === void 0) { + degreeAngle = 0; + } + var x = rectangle.x, y = rectangle.y, w = rectangle.width, h = rectangle.height; + var r = reduceRotation(degreeAngle); + var b = borderWidth / 2; + if (r === 0) + return { x: x - b, y: y - b, width: w, height: h }; + else if (r === 90) + return { x: x - h + b, y: y - b, width: h, height: w }; + else if (r === 180) + return { x: x - w + b, y: y - h + b, width: w, height: h }; + else if (r === 270) + return { x: x - b, y: y - w + b, width: h, height: w }; + else + return { x: x - b, y: y - b, width: w, height: h }; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/operators.js +var clip = function() { + return PDFOperator_default.of(PDFOperatorNames_default.ClipNonZero); +}; +var cos = Math.cos; +var sin = Math.sin; +var tan = Math.tan; +var concatTransformationMatrix = function(a, b, c, d, e, f) { + return PDFOperator_default.of(PDFOperatorNames_default.ConcatTransformationMatrix, [ + asPDFNumber(a), + asPDFNumber(b), + asPDFNumber(c), + asPDFNumber(d), + asPDFNumber(e), + asPDFNumber(f) + ]); +}; +var translate = function(xPos, yPos) { + return concatTransformationMatrix(1, 0, 0, 1, xPos, yPos); +}; +var scale = function(xPos, yPos) { + return concatTransformationMatrix(xPos, 0, 0, yPos, 0, 0); +}; +var rotateRadians = function(angle) { + return concatTransformationMatrix(cos(asNumber(angle)), sin(asNumber(angle)), -sin(asNumber(angle)), cos(asNumber(angle)), 0, 0); +}; +var rotateDegrees = function(angle) { + return rotateRadians(degreesToRadians(asNumber(angle))); +}; +var skewRadians = function(xSkewAngle, ySkewAngle) { + return concatTransformationMatrix(1, tan(asNumber(xSkewAngle)), tan(asNumber(ySkewAngle)), 1, 0, 0); +}; +var setDashPattern = function(dashArray, dashPhase) { + return PDFOperator_default.of(PDFOperatorNames_default.SetLineDashPattern, [ + "[" + dashArray.map(asPDFNumber).join(" ") + "]", + asPDFNumber(dashPhase) + ]); +}; +var LineCapStyle; +(function(LineCapStyle2) { + LineCapStyle2[LineCapStyle2["Butt"] = 0] = "Butt"; + LineCapStyle2[LineCapStyle2["Round"] = 1] = "Round"; + LineCapStyle2[LineCapStyle2["Projecting"] = 2] = "Projecting"; +})(LineCapStyle || (LineCapStyle = {})); +var setLineCap = function(style) { + return PDFOperator_default.of(PDFOperatorNames_default.SetLineCapStyle, [asPDFNumber(style)]); +}; +var LineJoinStyle; +(function(LineJoinStyle2) { + LineJoinStyle2[LineJoinStyle2["Miter"] = 0] = "Miter"; + LineJoinStyle2[LineJoinStyle2["Round"] = 1] = "Round"; + LineJoinStyle2[LineJoinStyle2["Bevel"] = 2] = "Bevel"; +})(LineJoinStyle || (LineJoinStyle = {})); +var setGraphicsState = function(state) { + return PDFOperator_default.of(PDFOperatorNames_default.SetGraphicsStateParams, [asPDFName(state)]); +}; +var pushGraphicsState = function() { + return PDFOperator_default.of(PDFOperatorNames_default.PushGraphicsState); +}; +var popGraphicsState = function() { + return PDFOperator_default.of(PDFOperatorNames_default.PopGraphicsState); +}; +var setLineWidth = function(width) { + return PDFOperator_default.of(PDFOperatorNames_default.SetLineWidth, [asPDFNumber(width)]); +}; +var appendBezierCurve = function(x1, y1, x2, y2, x3, y3) { + return PDFOperator_default.of(PDFOperatorNames_default.AppendBezierCurve, [ + asPDFNumber(x1), + asPDFNumber(y1), + asPDFNumber(x2), + asPDFNumber(y2), + asPDFNumber(x3), + asPDFNumber(y3) + ]); +}; +var appendQuadraticCurve = function(x1, y1, x2, y2) { + return PDFOperator_default.of(PDFOperatorNames_default.CurveToReplicateInitialPoint, [ + asPDFNumber(x1), + asPDFNumber(y1), + asPDFNumber(x2), + asPDFNumber(y2) + ]); +}; +var closePath = function() { + return PDFOperator_default.of(PDFOperatorNames_default.ClosePath); +}; +var moveTo = function(xPos, yPos) { + return PDFOperator_default.of(PDFOperatorNames_default.MoveTo, [asPDFNumber(xPos), asPDFNumber(yPos)]); +}; +var lineTo = function(xPos, yPos) { + return PDFOperator_default.of(PDFOperatorNames_default.LineTo, [asPDFNumber(xPos), asPDFNumber(yPos)]); +}; +var stroke = function() { + return PDFOperator_default.of(PDFOperatorNames_default.StrokePath); +}; +var fill = function() { + return PDFOperator_default.of(PDFOperatorNames_default.FillNonZero); +}; +var fillAndStroke = function() { + return PDFOperator_default.of(PDFOperatorNames_default.FillNonZeroAndStroke); +}; +var endPath = function() { + return PDFOperator_default.of(PDFOperatorNames_default.EndPath); +}; +var nextLine = function() { + return PDFOperator_default.of(PDFOperatorNames_default.NextLine); +}; +var showText = function(text) { + return PDFOperator_default.of(PDFOperatorNames_default.ShowText, [text]); +}; +var beginText = function() { + return PDFOperator_default.of(PDFOperatorNames_default.BeginText); +}; +var endText = function() { + return PDFOperator_default.of(PDFOperatorNames_default.EndText); +}; +var setFontAndSize = function(name, size) { + return PDFOperator_default.of(PDFOperatorNames_default.SetFontAndSize, [asPDFName(name), asPDFNumber(size)]); +}; +var setLineHeight = function(lineHeight) { + return PDFOperator_default.of(PDFOperatorNames_default.SetTextLineHeight, [asPDFNumber(lineHeight)]); +}; +var TextRenderingMode; +(function(TextRenderingMode2) { + TextRenderingMode2[TextRenderingMode2["Fill"] = 0] = "Fill"; + TextRenderingMode2[TextRenderingMode2["Outline"] = 1] = "Outline"; + TextRenderingMode2[TextRenderingMode2["FillAndOutline"] = 2] = "FillAndOutline"; + TextRenderingMode2[TextRenderingMode2["Invisible"] = 3] = "Invisible"; + TextRenderingMode2[TextRenderingMode2["FillAndClip"] = 4] = "FillAndClip"; + TextRenderingMode2[TextRenderingMode2["OutlineAndClip"] = 5] = "OutlineAndClip"; + TextRenderingMode2[TextRenderingMode2["FillAndOutlineAndClip"] = 6] = "FillAndOutlineAndClip"; + TextRenderingMode2[TextRenderingMode2["Clip"] = 7] = "Clip"; +})(TextRenderingMode || (TextRenderingMode = {})); +var setTextMatrix = function(a, b, c, d, e, f) { + return PDFOperator_default.of(PDFOperatorNames_default.SetTextMatrix, [ + asPDFNumber(a), + asPDFNumber(b), + asPDFNumber(c), + asPDFNumber(d), + asPDFNumber(e), + asPDFNumber(f) + ]); +}; +var rotateAndSkewTextRadiansAndTranslate = function(rotationAngle, xSkewAngle, ySkewAngle, x, y) { + return setTextMatrix(cos(asNumber(rotationAngle)), sin(asNumber(rotationAngle)) + tan(asNumber(xSkewAngle)), -sin(asNumber(rotationAngle)) + tan(asNumber(ySkewAngle)), cos(asNumber(rotationAngle)), x, y); +}; +var drawObject = function(name) { + return PDFOperator_default.of(PDFOperatorNames_default.DrawObject, [asPDFName(name)]); +}; +var setFillingGrayscaleColor = function(gray) { + return PDFOperator_default.of(PDFOperatorNames_default.NonStrokingColorGray, [asPDFNumber(gray)]); +}; +var setStrokingGrayscaleColor = function(gray) { + return PDFOperator_default.of(PDFOperatorNames_default.StrokingColorGray, [asPDFNumber(gray)]); +}; +var setFillingRgbColor = function(red, green, blue) { + return PDFOperator_default.of(PDFOperatorNames_default.NonStrokingColorRgb, [ + asPDFNumber(red), + asPDFNumber(green), + asPDFNumber(blue) + ]); +}; +var setStrokingRgbColor = function(red, green, blue) { + return PDFOperator_default.of(PDFOperatorNames_default.StrokingColorRgb, [ + asPDFNumber(red), + asPDFNumber(green), + asPDFNumber(blue) + ]); +}; +var setFillingCmykColor = function(cyan, magenta, yellow, key) { + return PDFOperator_default.of(PDFOperatorNames_default.NonStrokingColorCmyk, [ + asPDFNumber(cyan), + asPDFNumber(magenta), + asPDFNumber(yellow), + asPDFNumber(key) + ]); +}; +var setStrokingCmykColor = function(cyan, magenta, yellow, key) { + return PDFOperator_default.of(PDFOperatorNames_default.StrokingColorCmyk, [ + asPDFNumber(cyan), + asPDFNumber(magenta), + asPDFNumber(yellow), + asPDFNumber(key) + ]); +}; +var beginMarkedContent = function(tag) { + return PDFOperator_default.of(PDFOperatorNames_default.BeginMarkedContent, [asPDFName(tag)]); +}; +var endMarkedContent = function() { + return PDFOperator_default.of(PDFOperatorNames_default.EndMarkedContent); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/colors.js +var ColorTypes; +(function(ColorTypes2) { + ColorTypes2["Grayscale"] = "Grayscale"; + ColorTypes2["RGB"] = "RGB"; + ColorTypes2["CMYK"] = "CMYK"; +})(ColorTypes || (ColorTypes = {})); +var grayscale = function(gray) { + assertRange(gray, "gray", 0, 1); + return { type: ColorTypes.Grayscale, gray }; +}; +var rgb = function(red, green, blue) { + assertRange(red, "red", 0, 1); + assertRange(green, "green", 0, 1); + assertRange(blue, "blue", 0, 1); + return { type: ColorTypes.RGB, red, green, blue }; +}; +var cmyk = function(cyan, magenta, yellow, key) { + assertRange(cyan, "cyan", 0, 1); + assertRange(magenta, "magenta", 0, 1); + assertRange(yellow, "yellow", 0, 1); + assertRange(key, "key", 0, 1); + return { type: ColorTypes.CMYK, cyan, magenta, yellow, key }; +}; +var Grayscale = ColorTypes.Grayscale; +var RGB = ColorTypes.RGB; +var CMYK = ColorTypes.CMYK; +var setFillingColor = function(color) { + return color.type === Grayscale ? setFillingGrayscaleColor(color.gray) : color.type === RGB ? setFillingRgbColor(color.red, color.green, color.blue) : color.type === CMYK ? setFillingCmykColor(color.cyan, color.magenta, color.yellow, color.key) : error("Invalid color: " + JSON.stringify(color)); +}; +var setStrokingColor = function(color) { + return color.type === Grayscale ? setStrokingGrayscaleColor(color.gray) : color.type === RGB ? setStrokingRgbColor(color.red, color.green, color.blue) : color.type === CMYK ? setStrokingCmykColor(color.cyan, color.magenta, color.yellow, color.key) : error("Invalid color: " + JSON.stringify(color)); +}; +var componentsToColor = function(comps, scale2) { + if (scale2 === void 0) { + scale2 = 1; + } + return (comps === null || comps === void 0 ? void 0 : comps.length) === 1 ? grayscale(comps[0] * scale2) : (comps === null || comps === void 0 ? void 0 : comps.length) === 3 ? rgb(comps[0] * scale2, comps[1] * scale2, comps[2] * scale2) : (comps === null || comps === void 0 ? void 0 : comps.length) === 4 ? cmyk(comps[0] * scale2, comps[1] * scale2, comps[2] * scale2, comps[3] * scale2) : void 0; +}; +var colorToComponents = function(color) { + return color.type === Grayscale ? [color.gray] : color.type === RGB ? [color.red, color.green, color.blue] : color.type === CMYK ? [color.cyan, color.magenta, color.yellow, color.key] : error("Invalid color: " + JSON.stringify(color)); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/svgPath.js +var cx = 0; +var cy = 0; +var px = 0; +var py = 0; +var sx = 0; +var sy = 0; +var parameters = /* @__PURE__ */ new Map([ + ["A", 7], + ["a", 7], + ["C", 6], + ["c", 6], + ["H", 1], + ["h", 1], + ["L", 2], + ["l", 2], + ["M", 2], + ["m", 2], + ["Q", 4], + ["q", 4], + ["S", 4], + ["s", 4], + ["T", 2], + ["t", 2], + ["V", 1], + ["v", 1], + ["Z", 0], + ["z", 0] +]); +var parse = function(path2) { + var cmd; + var ret = []; + var args = []; + var curArg = ""; + var foundDecimal = false; + var params = 0; + for (var _i = 0, path_1 = path2; _i < path_1.length; _i++) { + var c = path_1[_i]; + if (parameters.has(c)) { + params = parameters.get(c); + if (cmd) { + if (curArg.length > 0) { + args[args.length] = +curArg; + } + ret[ret.length] = { cmd, args }; + args = []; + curArg = ""; + foundDecimal = false; + } + cmd = c; + } else if ([" ", ","].includes(c) || c === "-" && curArg.length > 0 && curArg[curArg.length - 1] !== "e" || c === "." && foundDecimal) { + if (curArg.length === 0) { + continue; + } + if (args.length === params) { + ret[ret.length] = { cmd, args }; + args = [+curArg]; + if (cmd === "M") { + cmd = "L"; + } + if (cmd === "m") { + cmd = "l"; + } + } else { + args[args.length] = +curArg; + } + foundDecimal = c === "."; + curArg = ["-", "."].includes(c) ? c : ""; + } else { + curArg += c; + if (c === ".") { + foundDecimal = true; + } + } + } + if (curArg.length > 0) { + if (args.length === params) { + ret[ret.length] = { cmd, args }; + args = [+curArg]; + if (cmd === "M") { + cmd = "L"; + } + if (cmd === "m") { + cmd = "l"; + } + } else { + args[args.length] = +curArg; + } + } + ret[ret.length] = { cmd, args }; + return ret; +}; +var apply = function(commands) { + cx = cy = px = py = sx = sy = 0; + var cmds = []; + for (var i = 0; i < commands.length; i++) { + var c = commands[i]; + if (c.cmd && typeof runners[c.cmd] === "function") { + var cmd = runners[c.cmd](c.args); + if (Array.isArray(cmd)) { + cmds = cmds.concat(cmd); + } else { + cmds.push(cmd); + } + } + } + return cmds; +}; +var runners = { + M: function(a) { + cx = a[0]; + cy = a[1]; + px = py = null; + sx = cx; + sy = cy; + return moveTo(cx, cy); + }, + m: function(a) { + cx += a[0]; + cy += a[1]; + px = py = null; + sx = cx; + sy = cy; + return moveTo(cx, cy); + }, + C: function(a) { + cx = a[4]; + cy = a[5]; + px = a[2]; + py = a[3]; + return appendBezierCurve(a[0], a[1], a[2], a[3], a[4], a[5]); + }, + c: function(a) { + var cmd = appendBezierCurve(a[0] + cx, a[1] + cy, a[2] + cx, a[3] + cy, a[4] + cx, a[5] + cy); + px = cx + a[2]; + py = cy + a[3]; + cx += a[4]; + cy += a[5]; + return cmd; + }, + S: function(a) { + if (px === null || py === null) { + px = cx; + py = cy; + } + var cmd = appendBezierCurve(cx - (px - cx), cy - (py - cy), a[0], a[1], a[2], a[3]); + px = a[0]; + py = a[1]; + cx = a[2]; + cy = a[3]; + return cmd; + }, + s: function(a) { + if (px === null || py === null) { + px = cx; + py = cy; + } + var cmd = appendBezierCurve(cx - (px - cx), cy - (py - cy), cx + a[0], cy + a[1], cx + a[2], cy + a[3]); + px = cx + a[0]; + py = cy + a[1]; + cx += a[2]; + cy += a[3]; + return cmd; + }, + Q: function(a) { + px = a[0]; + py = a[1]; + cx = a[2]; + cy = a[3]; + return appendQuadraticCurve(a[0], a[1], cx, cy); + }, + q: function(a) { + var cmd = appendQuadraticCurve(a[0] + cx, a[1] + cy, a[2] + cx, a[3] + cy); + px = cx + a[0]; + py = cy + a[1]; + cx += a[2]; + cy += a[3]; + return cmd; + }, + T: function(a) { + if (px === null || py === null) { + px = cx; + py = cy; + } else { + px = cx - (px - cx); + py = cy - (py - cy); + } + var cmd = appendQuadraticCurve(px, py, a[0], a[1]); + px = cx - (px - cx); + py = cy - (py - cy); + cx = a[0]; + cy = a[1]; + return cmd; + }, + t: function(a) { + if (px === null || py === null) { + px = cx; + py = cy; + } else { + px = cx - (px - cx); + py = cy - (py - cy); + } + var cmd = appendQuadraticCurve(px, py, cx + a[0], cy + a[1]); + cx += a[0]; + cy += a[1]; + return cmd; + }, + A: function(a) { + var cmds = solveArc(cx, cy, a); + cx = a[5]; + cy = a[6]; + return cmds; + }, + a: function(a) { + a[5] += cx; + a[6] += cy; + var cmds = solveArc(cx, cy, a); + cx = a[5]; + cy = a[6]; + return cmds; + }, + L: function(a) { + cx = a[0]; + cy = a[1]; + px = py = null; + return lineTo(cx, cy); + }, + l: function(a) { + cx += a[0]; + cy += a[1]; + px = py = null; + return lineTo(cx, cy); + }, + H: function(a) { + cx = a[0]; + px = py = null; + return lineTo(cx, cy); + }, + h: function(a) { + cx += a[0]; + px = py = null; + return lineTo(cx, cy); + }, + V: function(a) { + cy = a[0]; + px = py = null; + return lineTo(cx, cy); + }, + v: function(a) { + cy += a[0]; + px = py = null; + return lineTo(cx, cy); + }, + Z: function() { + var cmd = closePath(); + cx = sx; + cy = sy; + return cmd; + }, + z: function() { + var cmd = closePath(); + cx = sx; + cy = sy; + return cmd; + } +}; +var solveArc = function(x, y, coords) { + var rx = coords[0], ry = coords[1], rot = coords[2], large = coords[3], sweep = coords[4], ex = coords[5], ey = coords[6]; + var segs = arcToSegments(ex, ey, rx, ry, large, sweep, rot, x, y); + var cmds = []; + for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) { + var seg = segs_1[_i]; + var bez = segmentToBezier.apply(void 0, seg); + cmds.push(appendBezierCurve.apply(void 0, bez)); + } + return cmds; +}; +var arcToSegments = function(x, y, rx, ry, large, sweep, rotateX, ox, oy) { + var th = rotateX * (Math.PI / 180); + var sinTh = Math.sin(th); + var cosTh = Math.cos(th); + rx = Math.abs(rx); + ry = Math.abs(ry); + px = cosTh * (ox - x) * 0.5 + sinTh * (oy - y) * 0.5; + py = cosTh * (oy - y) * 0.5 - sinTh * (ox - x) * 0.5; + var pl = px * px / (rx * rx) + py * py / (ry * ry); + if (pl > 1) { + pl = Math.sqrt(pl); + rx *= pl; + ry *= pl; + } + var a00 = cosTh / rx; + var a01 = sinTh / rx; + var a10 = -sinTh / ry; + var a11 = cosTh / ry; + var x0 = a00 * ox + a01 * oy; + var y0 = a10 * ox + a11 * oy; + var x1 = a00 * x + a01 * y; + var y1 = a10 * x + a11 * y; + var d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0); + var sfactorSq = 1 / d - 0.25; + if (sfactorSq < 0) { + sfactorSq = 0; + } + var sfactor = Math.sqrt(sfactorSq); + if (sweep === large) { + sfactor = -sfactor; + } + var xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0); + var yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0); + var th0 = Math.atan2(y0 - yc, x0 - xc); + var th1 = Math.atan2(y1 - yc, x1 - xc); + var thArc = th1 - th0; + if (thArc < 0 && sweep === 1) { + thArc += 2 * Math.PI; + } else if (thArc > 0 && sweep === 0) { + thArc -= 2 * Math.PI; + } + var segments = Math.ceil(Math.abs(thArc / (Math.PI * 0.5 + 1e-3))); + var result = []; + for (var i = 0; i < segments; i++) { + var th2 = th0 + i * thArc / segments; + var th3 = th0 + (i + 1) * thArc / segments; + result[i] = [xc, yc, th2, th3, rx, ry, sinTh, cosTh]; + } + return result; +}; +var segmentToBezier = function(cx1, cy1, th0, th1, rx, ry, sinTh, cosTh) { + var a00 = cosTh * rx; + var a01 = -sinTh * ry; + var a10 = sinTh * rx; + var a11 = cosTh * ry; + var thHalf = 0.5 * (th1 - th0); + var t = 8 / 3 * Math.sin(thHalf * 0.5) * Math.sin(thHalf * 0.5) / Math.sin(thHalf); + var x1 = cx1 + Math.cos(th0) - t * Math.sin(th0); + var y1 = cy1 + Math.sin(th0) + t * Math.cos(th0); + var x3 = cx1 + Math.cos(th1); + var y3 = cy1 + Math.sin(th1); + var x2 = x3 + t * Math.sin(th1); + var y2 = y3 - t * Math.cos(th1); + var result = [ + a00 * x1 + a01 * y1, + a10 * x1 + a11 * y1, + a00 * x2 + a01 * y2, + a10 * x2 + a11 * y2, + a00 * x3 + a01 * y3, + a10 * x3 + a11 * y3 + ]; + return result; +}; +var svgPathToOperators = function(path2) { + return apply(parse(path2)); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/operations.js +var drawLinesOfText = function(lines, options) { + var operators = [ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + beginText(), + setFillingColor(options.color), + setFontAndSize(options.font, options.size), + setLineHeight(options.lineHeight), + rotateAndSkewTextRadiansAndTranslate(toRadians(options.rotate), toRadians(options.xSkew), toRadians(options.ySkew), options.x, options.y) + ].filter(Boolean); + for (var idx = 0, len = lines.length; idx < len; idx++) { + operators.push(showText(lines[idx]), nextLine()); + } + operators.push(endText(), popGraphicsState()); + return operators; +}; +var drawImage = function(name, options) { + return [ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + translate(options.x, options.y), + rotateRadians(toRadians(options.rotate)), + scale(options.width, options.height), + skewRadians(toRadians(options.xSkew), toRadians(options.ySkew)), + drawObject(name), + popGraphicsState() + ].filter(Boolean); +}; +var drawPage = function(name, options) { + return [ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + translate(options.x, options.y), + rotateRadians(toRadians(options.rotate)), + scale(options.xScale, options.yScale), + skewRadians(toRadians(options.xSkew), toRadians(options.ySkew)), + drawObject(name), + popGraphicsState() + ].filter(Boolean); +}; +var drawLine = function(options) { + var _a, _b; + return [ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + options.color && setStrokingColor(options.color), + setLineWidth(options.thickness), + setDashPattern((_a = options.dashArray) !== null && _a !== void 0 ? _a : [], (_b = options.dashPhase) !== null && _b !== void 0 ? _b : 0), + moveTo(options.start.x, options.start.y), + options.lineCap && setLineCap(options.lineCap), + moveTo(options.start.x, options.start.y), + lineTo(options.end.x, options.end.y), + stroke(), + popGraphicsState() + ].filter(Boolean); +}; +var drawRectangle = function(options) { + var _a, _b; + return [ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + options.color && setFillingColor(options.color), + options.borderColor && setStrokingColor(options.borderColor), + setLineWidth(options.borderWidth), + options.borderLineCap && setLineCap(options.borderLineCap), + setDashPattern((_a = options.borderDashArray) !== null && _a !== void 0 ? _a : [], (_b = options.borderDashPhase) !== null && _b !== void 0 ? _b : 0), + translate(options.x, options.y), + rotateRadians(toRadians(options.rotate)), + skewRadians(toRadians(options.xSkew), toRadians(options.ySkew)), + moveTo(0, 0), + lineTo(0, options.height), + lineTo(options.width, options.height), + lineTo(options.width, 0), + closePath(), + // prettier-ignore + options.color && options.borderWidth ? fillAndStroke() : options.color ? fill() : options.borderColor ? stroke() : closePath(), + popGraphicsState() + ].filter(Boolean); +}; +var KAPPA = 4 * ((Math.sqrt(2) - 1) / 3); +var drawEllipsePath = function(config) { + var x = asNumber(config.x); + var y = asNumber(config.y); + var xScale = asNumber(config.xScale); + var yScale = asNumber(config.yScale); + x -= xScale; + y -= yScale; + var ox = xScale * KAPPA; + var oy = yScale * KAPPA; + var xe = x + xScale * 2; + var ye = y + yScale * 2; + var xm = x + xScale; + var ym = y + yScale; + return [ + pushGraphicsState(), + moveTo(x, ym), + appendBezierCurve(x, ym - oy, xm - ox, y, xm, y), + appendBezierCurve(xm + ox, y, xe, ym - oy, xe, ym), + appendBezierCurve(xe, ym + oy, xm + ox, ye, xm, ye), + appendBezierCurve(xm - ox, ye, x, ym + oy, x, ym), + popGraphicsState() + ]; +}; +var drawEllipseCurves = function(config) { + var centerX = asNumber(config.x); + var centerY = asNumber(config.y); + var xScale = asNumber(config.xScale); + var yScale = asNumber(config.yScale); + var x = -xScale; + var y = -yScale; + var ox = xScale * KAPPA; + var oy = yScale * KAPPA; + var xe = x + xScale * 2; + var ye = y + yScale * 2; + var xm = x + xScale; + var ym = y + yScale; + return [ + translate(centerX, centerY), + rotateRadians(toRadians(config.rotate)), + moveTo(x, ym), + appendBezierCurve(x, ym - oy, xm - ox, y, xm, y), + appendBezierCurve(xm + ox, y, xe, ym - oy, xe, ym), + appendBezierCurve(xe, ym + oy, xm + ox, ye, xm, ye), + appendBezierCurve(xm - ox, ye, x, ym + oy, x, ym) + ]; +}; +var drawEllipse = function(options) { + var _a, _b, _c; + return __spreadArrays([ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + options.color && setFillingColor(options.color), + options.borderColor && setStrokingColor(options.borderColor), + setLineWidth(options.borderWidth), + options.borderLineCap && setLineCap(options.borderLineCap), + setDashPattern((_a = options.borderDashArray) !== null && _a !== void 0 ? _a : [], (_b = options.borderDashPhase) !== null && _b !== void 0 ? _b : 0) + ], options.rotate === void 0 ? drawEllipsePath({ + x: options.x, + y: options.y, + xScale: options.xScale, + yScale: options.yScale + }) : drawEllipseCurves({ + x: options.x, + y: options.y, + xScale: options.xScale, + yScale: options.yScale, + rotate: (_c = options.rotate) !== null && _c !== void 0 ? _c : degrees(0) + }), [ + // prettier-ignore + options.color && options.borderWidth ? fillAndStroke() : options.color ? fill() : options.borderColor ? stroke() : closePath(), + popGraphicsState() + ]).filter(Boolean); +}; +var drawSvgPath = function(path2, options) { + var _a, _b, _c; + return __spreadArrays([ + pushGraphicsState(), + options.graphicsState && setGraphicsState(options.graphicsState), + translate(options.x, options.y), + rotateRadians(toRadians((_a = options.rotate) !== null && _a !== void 0 ? _a : degrees(0))), + // SVG path Y axis is opposite pdf-lib's + options.scale ? scale(options.scale, -options.scale) : scale(1, -1), + options.color && setFillingColor(options.color), + options.borderColor && setStrokingColor(options.borderColor), + options.borderWidth && setLineWidth(options.borderWidth), + options.borderLineCap && setLineCap(options.borderLineCap), + setDashPattern((_b = options.borderDashArray) !== null && _b !== void 0 ? _b : [], (_c = options.borderDashPhase) !== null && _c !== void 0 ? _c : 0) + ], svgPathToOperators(path2), [ + // prettier-ignore + options.color && options.borderWidth ? fillAndStroke() : options.color ? fill() : options.borderColor ? stroke() : closePath(), + popGraphicsState() + ]).filter(Boolean); +}; +var drawCheckMark = function(options) { + var size = asNumber(options.size); + var p2x = -1 + 0.75; + var p2y = -1 + 0.51; + var p3y = 1 - 0.525; + var p3x = 1 - 0.31; + var p1x = -1 + 0.325; + var p1y = -((p1x - p2x) * (p3x - p2x)) / (p3y - p2y) + p2y; + return [ + pushGraphicsState(), + options.color && setStrokingColor(options.color), + setLineWidth(options.thickness), + translate(options.x, options.y), + moveTo(p1x * size, p1y * size), + lineTo(p2x * size, p2y * size), + lineTo(p3x * size, p3y * size), + stroke(), + popGraphicsState() + ].filter(Boolean); +}; +var rotateInPlace = function(options) { + return options.rotation === 0 ? [ + translate(0, 0), + rotateDegrees(0) + ] : options.rotation === 90 ? [ + translate(options.width, 0), + rotateDegrees(90) + ] : options.rotation === 180 ? [ + translate(options.width, options.height), + rotateDegrees(180) + ] : options.rotation === 270 ? [ + translate(0, options.height), + rotateDegrees(270) + ] : []; +}; +var drawCheckBox = function(options) { + var outline = drawRectangle({ + x: options.x, + y: options.y, + width: options.width, + height: options.height, + borderWidth: options.borderWidth, + color: options.color, + borderColor: options.borderColor, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + if (!options.filled) + return outline; + var width = asNumber(options.width); + var height = asNumber(options.height); + var checkMarkSize = Math.min(width, height) / 2; + var checkMark = drawCheckMark({ + x: width / 2, + y: height / 2, + size: checkMarkSize, + thickness: options.thickness, + color: options.markColor + }); + return __spreadArrays([pushGraphicsState()], outline, checkMark, [popGraphicsState()]); +}; +var drawRadioButton = function(options) { + var width = asNumber(options.width); + var height = asNumber(options.height); + var outlineScale = Math.min(width, height) / 2; + var outline = drawEllipse({ + x: options.x, + y: options.y, + xScale: outlineScale, + yScale: outlineScale, + color: options.color, + borderColor: options.borderColor, + borderWidth: options.borderWidth + }); + if (!options.filled) + return outline; + var dot = drawEllipse({ + x: options.x, + y: options.y, + xScale: outlineScale * 0.45, + yScale: outlineScale * 0.45, + color: options.dotColor, + borderColor: void 0, + borderWidth: 0 + }); + return __spreadArrays([pushGraphicsState()], outline, dot, [popGraphicsState()]); +}; +var drawButton = function(options) { + var x = asNumber(options.x); + var y = asNumber(options.y); + var width = asNumber(options.width); + var height = asNumber(options.height); + var background = drawRectangle({ + x, + y, + width, + height, + borderWidth: options.borderWidth, + color: options.color, + borderColor: options.borderColor, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + var lines = drawTextLines(options.textLines, { + color: options.textColor, + font: options.font, + size: options.fontSize, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + return __spreadArrays([pushGraphicsState()], background, lines, [popGraphicsState()]); +}; +var drawTextLines = function(lines, options) { + var operators = [ + beginText(), + setFillingColor(options.color), + setFontAndSize(options.font, options.size) + ]; + for (var idx = 0, len = lines.length; idx < len; idx++) { + var _a = lines[idx], encoded = _a.encoded, x = _a.x, y = _a.y; + operators.push(rotateAndSkewTextRadiansAndTranslate(toRadians(options.rotate), toRadians(options.xSkew), toRadians(options.ySkew), x, y), showText(encoded)); + } + operators.push(endText()); + return operators; +}; +var drawTextField = function(options) { + var x = asNumber(options.x); + var y = asNumber(options.y); + var width = asNumber(options.width); + var height = asNumber(options.height); + var borderWidth = asNumber(options.borderWidth); + var padding = asNumber(options.padding); + var clipX = x + borderWidth / 2 + padding; + var clipY = y + borderWidth / 2 + padding; + var clipWidth = width - (borderWidth / 2 + padding) * 2; + var clipHeight = height - (borderWidth / 2 + padding) * 2; + var clippingArea = [ + moveTo(clipX, clipY), + lineTo(clipX, clipY + clipHeight), + lineTo(clipX + clipWidth, clipY + clipHeight), + lineTo(clipX + clipWidth, clipY), + closePath(), + clip(), + endPath() + ]; + var background = drawRectangle({ + x, + y, + width, + height, + borderWidth: options.borderWidth, + color: options.color, + borderColor: options.borderColor, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + var lines = drawTextLines(options.textLines, { + color: options.textColor, + font: options.font, + size: options.fontSize, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + var markedContent = __spreadArrays([ + beginMarkedContent("Tx"), + pushGraphicsState() + ], lines, [ + popGraphicsState(), + endMarkedContent() + ]); + return __spreadArrays([ + pushGraphicsState() + ], background, clippingArea, markedContent, [ + popGraphicsState() + ]); +}; +var drawOptionList = function(options) { + var x = asNumber(options.x); + var y = asNumber(options.y); + var width = asNumber(options.width); + var height = asNumber(options.height); + var lineHeight = asNumber(options.lineHeight); + var borderWidth = asNumber(options.borderWidth); + var padding = asNumber(options.padding); + var clipX = x + borderWidth / 2 + padding; + var clipY = y + borderWidth / 2 + padding; + var clipWidth = width - (borderWidth / 2 + padding) * 2; + var clipHeight = height - (borderWidth / 2 + padding) * 2; + var clippingArea = [ + moveTo(clipX, clipY), + lineTo(clipX, clipY + clipHeight), + lineTo(clipX + clipWidth, clipY + clipHeight), + lineTo(clipX + clipWidth, clipY), + closePath(), + clip(), + endPath() + ]; + var background = drawRectangle({ + x, + y, + width, + height, + borderWidth: options.borderWidth, + color: options.color, + borderColor: options.borderColor, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + var highlights = []; + for (var idx = 0, len = options.selectedLines.length; idx < len; idx++) { + var line = options.textLines[options.selectedLines[idx]]; + highlights.push.apply(highlights, drawRectangle({ + x: line.x - padding, + y: line.y - (lineHeight - line.height) / 2, + width: width - borderWidth, + height: line.height + (lineHeight - line.height) / 2, + borderWidth: 0, + color: options.selectedColor, + borderColor: void 0, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + })); + } + var lines = drawTextLines(options.textLines, { + color: options.textColor, + font: options.font, + size: options.fontSize, + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }); + var markedContent = __spreadArrays([ + beginMarkedContent("Tx"), + pushGraphicsState() + ], lines, [ + popGraphicsState(), + endMarkedContent() + ]); + return __spreadArrays([ + pushGraphicsState() + ], background, highlights, clippingArea, markedContent, [ + popGraphicsState() + ]); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/errors.js +var EncryptedPDFError = ( + /** @class */ + function(_super) { + __extends(EncryptedPDFError2, _super); + function EncryptedPDFError2() { + var _this = this; + var msg = "Input document to `PDFDocument.load` is encrypted. You can use `PDFDocument.load(..., { ignoreEncryption: true })` if you wish to load the document anyways."; + _this = _super.call(this, msg) || this; + return _this; + } + return EncryptedPDFError2; + }(Error) +); +var FontkitNotRegisteredError = ( + /** @class */ + function(_super) { + __extends(FontkitNotRegisteredError2, _super); + function FontkitNotRegisteredError2() { + var _this = this; + var msg = "Input to `PDFDocument.embedFont` was a custom font, but no `fontkit` instance was found. You must register a `fontkit` instance with `PDFDocument.registerFontkit(...)` before embedding custom fonts."; + _this = _super.call(this, msg) || this; + return _this; + } + return FontkitNotRegisteredError2; + }(Error) +); +var ForeignPageError = ( + /** @class */ + function(_super) { + __extends(ForeignPageError2, _super); + function ForeignPageError2() { + var _this = this; + var msg = "A `page` passed to `PDFDocument.addPage` or `PDFDocument.insertPage` was from a different (foreign) PDF document. If you want to copy pages from one PDFDocument to another, you must use `PDFDocument.copyPages(...)` to copy the pages before adding or inserting them."; + _this = _super.call(this, msg) || this; + return _this; + } + return ForeignPageError2; + }(Error) +); +var RemovePageFromEmptyDocumentError = ( + /** @class */ + function(_super) { + __extends(RemovePageFromEmptyDocumentError2, _super); + function RemovePageFromEmptyDocumentError2() { + var _this = this; + var msg = "PDFDocument has no pages so `PDFDocument.removePage` cannot be called"; + _this = _super.call(this, msg) || this; + return _this; + } + return RemovePageFromEmptyDocumentError2; + }(Error) +); +var NoSuchFieldError = ( + /** @class */ + function(_super) { + __extends(NoSuchFieldError2, _super); + function NoSuchFieldError2(name) { + var _this = this; + var msg = 'PDFDocument has no form field with the name "' + name + '"'; + _this = _super.call(this, msg) || this; + return _this; + } + return NoSuchFieldError2; + }(Error) +); +var UnexpectedFieldTypeError = ( + /** @class */ + function(_super) { + __extends(UnexpectedFieldTypeError2, _super); + function UnexpectedFieldTypeError2(name, expected, actual) { + var _a, _b; + var _this = this; + var expectedType = expected === null || expected === void 0 ? void 0 : expected.name; + var actualType = (_b = (_a = actual === null || actual === void 0 ? void 0 : actual.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : actual; + var msg = 'Expected field "' + name + '" to be of type ' + expectedType + ", " + ("but it is actually of type " + actualType); + _this = _super.call(this, msg) || this; + return _this; + } + return UnexpectedFieldTypeError2; + }(Error) +); +var MissingOnValueCheckError = ( + /** @class */ + function(_super) { + __extends(MissingOnValueCheckError2, _super); + function MissingOnValueCheckError2(onValue) { + var _this = this; + var msg = 'Failed to select check box due to missing onValue: "' + onValue + '"'; + _this = _super.call(this, msg) || this; + return _this; + } + return MissingOnValueCheckError2; + }(Error) +); +var FieldAlreadyExistsError = ( + /** @class */ + function(_super) { + __extends(FieldAlreadyExistsError2, _super); + function FieldAlreadyExistsError2(name) { + var _this = this; + var msg = 'A field already exists with the specified name: "' + name + '"'; + _this = _super.call(this, msg) || this; + return _this; + } + return FieldAlreadyExistsError2; + }(Error) +); +var InvalidFieldNamePartError = ( + /** @class */ + function(_super) { + __extends(InvalidFieldNamePartError2, _super); + function InvalidFieldNamePartError2(namePart) { + var _this = this; + var msg = 'Field name contains invalid component: "' + namePart + '"'; + _this = _super.call(this, msg) || this; + return _this; + } + return InvalidFieldNamePartError2; + }(Error) +); +var FieldExistsAsNonTerminalError = ( + /** @class */ + function(_super) { + __extends(FieldExistsAsNonTerminalError2, _super); + function FieldExistsAsNonTerminalError2(name) { + var _this = this; + var msg = 'A non-terminal field already exists with the specified name: "' + name + '"'; + _this = _super.call(this, msg) || this; + return _this; + } + return FieldExistsAsNonTerminalError2; + }(Error) +); +var RichTextFieldReadError = ( + /** @class */ + function(_super) { + __extends(RichTextFieldReadError2, _super); + function RichTextFieldReadError2(fieldName) { + var _this = this; + var msg = "Reading rich text fields is not supported: Attempted to read rich text field: " + fieldName; + _this = _super.call(this, msg) || this; + return _this; + } + return RichTextFieldReadError2; + }(Error) +); +var CombedTextLayoutError = ( + /** @class */ + function(_super) { + __extends(CombedTextLayoutError2, _super); + function CombedTextLayoutError2(lineLength, cellCount) { + var _this = this; + var msg = "Failed to layout combed text as lineLength=" + lineLength + " is greater than cellCount=" + cellCount; + _this = _super.call(this, msg) || this; + return _this; + } + return CombedTextLayoutError2; + }(Error) +); +var ExceededMaxLengthError = ( + /** @class */ + function(_super) { + __extends(ExceededMaxLengthError2, _super); + function ExceededMaxLengthError2(textLength, maxLength, name) { + var _this = this; + var msg = "Attempted to set text with length=" + textLength + " for TextField with maxLength=" + maxLength + " and name=" + name; + _this = _super.call(this, msg) || this; + return _this; + } + return ExceededMaxLengthError2; + }(Error) +); +var InvalidMaxLengthError = ( + /** @class */ + function(_super) { + __extends(InvalidMaxLengthError2, _super); + function InvalidMaxLengthError2(textLength, maxLength, name) { + var _this = this; + var msg = "Attempted to set maxLength=" + maxLength + ", which is less than " + textLength + ", the length of this field's current value (name=" + name + ")"; + _this = _super.call(this, msg) || this; + return _this; + } + return InvalidMaxLengthError2; + }(Error) +); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/text/alignment.js +var TextAlignment; +(function(TextAlignment2) { + TextAlignment2[TextAlignment2["Left"] = 0] = "Left"; + TextAlignment2[TextAlignment2["Center"] = 1] = "Center"; + TextAlignment2[TextAlignment2["Right"] = 2] = "Right"; +})(TextAlignment || (TextAlignment = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/text/layout.js +var MIN_FONT_SIZE = 4; +var MAX_FONT_SIZE = 500; +var computeFontSize = function(lines, font, bounds, multiline) { + if (multiline === void 0) { + multiline = false; + } + var fontSize = MIN_FONT_SIZE; + while (fontSize < MAX_FONT_SIZE) { + var linesUsed = 0; + for (var lineIdx = 0, lineLen = lines.length; lineIdx < lineLen; lineIdx++) { + linesUsed += 1; + var line = lines[lineIdx]; + var words = line.split(" "); + var spaceInLineRemaining = bounds.width; + for (var idx = 0, len = words.length; idx < len; idx++) { + var isLastWord = idx === len - 1; + var word = isLastWord ? words[idx] : words[idx] + " "; + var widthOfWord = font.widthOfTextAtSize(word, fontSize); + spaceInLineRemaining -= widthOfWord; + if (spaceInLineRemaining <= 0) { + linesUsed += 1; + spaceInLineRemaining = bounds.width - widthOfWord; + } + } + } + if (!multiline && linesUsed > lines.length) + return fontSize - 1; + var height = font.heightAtSize(fontSize); + var lineHeight = height + height * 0.2; + var totalHeight = lineHeight * linesUsed; + if (totalHeight > Math.abs(bounds.height)) + return fontSize - 1; + fontSize += 1; + } + return fontSize; +}; +var computeCombedFontSize = function(line, font, bounds, cellCount) { + var cellWidth = bounds.width / cellCount; + var cellHeight = bounds.height; + var fontSize = MIN_FONT_SIZE; + var chars3 = charSplit(line); + while (fontSize < MAX_FONT_SIZE) { + for (var idx = 0, len = chars3.length; idx < len; idx++) { + var c = chars3[idx]; + var tooLong = font.widthOfTextAtSize(c, fontSize) > cellWidth * 0.75; + if (tooLong) + return fontSize - 1; + } + var height = font.heightAtSize(fontSize, { descender: false }); + if (height > cellHeight) + return fontSize - 1; + fontSize += 1; + } + return fontSize; +}; +var lastIndexOfWhitespace = function(line) { + for (var idx = line.length; idx > 0; idx--) { + if (/\s/.test(line[idx])) + return idx; + } + return void 0; +}; +var splitOutLines = function(input, maxWidth, font, fontSize) { + var _a; + var lastWhitespaceIdx = input.length; + while (lastWhitespaceIdx > 0) { + var line = input.substring(0, lastWhitespaceIdx); + var encoded = font.encodeText(line); + var width = font.widthOfTextAtSize(line, fontSize); + if (width < maxWidth) { + var remainder = input.substring(lastWhitespaceIdx) || void 0; + return { line, encoded, width, remainder }; + } + lastWhitespaceIdx = (_a = lastIndexOfWhitespace(line)) !== null && _a !== void 0 ? _a : 0; + } + return { + line: input, + encoded: font.encodeText(input), + width: font.widthOfTextAtSize(input, fontSize), + remainder: void 0 + }; +}; +var layoutMultilineText = function(text, _a) { + var alignment = _a.alignment, fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds; + var lines = lineSplit(cleanText(text)); + if (fontSize === void 0 || fontSize === 0) { + fontSize = computeFontSize(lines, font, bounds, true); + } + var height = font.heightAtSize(fontSize); + var lineHeight = height + height * 0.2; + var textLines = []; + var minX = bounds.x; + var minY = bounds.y; + var maxX = bounds.x + bounds.width; + var maxY = bounds.y + bounds.height; + var y = bounds.y + bounds.height; + for (var idx = 0, len = lines.length; idx < len; idx++) { + var prevRemainder = lines[idx]; + while (prevRemainder !== void 0) { + var _b = splitOutLines(prevRemainder, bounds.width, font, fontSize), line = _b.line, encoded = _b.encoded, width = _b.width, remainder = _b.remainder; + var x = alignment === TextAlignment.Left ? bounds.x : alignment === TextAlignment.Center ? bounds.x + bounds.width / 2 - width / 2 : alignment === TextAlignment.Right ? bounds.x + bounds.width - width : bounds.x; + y -= lineHeight; + if (x < minX) + minX = x; + if (y < minY) + minY = y; + if (x + width > maxX) + maxX = x + width; + if (y + height > maxY) + maxY = y + height; + textLines.push({ text: line, encoded, width, height, x, y }); + prevRemainder = remainder === null || remainder === void 0 ? void 0 : remainder.trim(); + } + } + return { + fontSize, + lineHeight, + lines: textLines, + bounds: { + x: minX, + y: minY, + width: maxX - minX, + height: maxY - minY + } + }; +}; +var layoutCombedText = function(text, _a) { + var fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds, cellCount = _a.cellCount; + var line = mergeLines(cleanText(text)); + if (line.length > cellCount) { + throw new CombedTextLayoutError(line.length, cellCount); + } + if (fontSize === void 0 || fontSize === 0) { + fontSize = computeCombedFontSize(line, font, bounds, cellCount); + } + var cellWidth = bounds.width / cellCount; + var height = font.heightAtSize(fontSize, { descender: false }); + var y = bounds.y + (bounds.height / 2 - height / 2); + var cells = []; + var minX = bounds.x; + var minY = bounds.y; + var maxX = bounds.x + bounds.width; + var maxY = bounds.y + bounds.height; + var cellOffset = 0; + var charOffset = 0; + while (cellOffset < cellCount) { + var _b = charAtIndex(line, charOffset), char = _b[0], charLength = _b[1]; + var encoded = font.encodeText(char); + var width = font.widthOfTextAtSize(char, fontSize); + var cellCenter = bounds.x + (cellWidth * cellOffset + cellWidth / 2); + var x = cellCenter - width / 2; + if (x < minX) + minX = x; + if (y < minY) + minY = y; + if (x + width > maxX) + maxX = x + width; + if (y + height > maxY) + maxY = y + height; + cells.push({ text: line, encoded, width, height, x, y }); + cellOffset += 1; + charOffset += charLength; + } + return { + fontSize, + cells, + bounds: { + x: minX, + y: minY, + width: maxX - minX, + height: maxY - minY + } + }; +}; +var layoutSinglelineText = function(text, _a) { + var alignment = _a.alignment, fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds; + var line = mergeLines(cleanText(text)); + if (fontSize === void 0 || fontSize === 0) { + fontSize = computeFontSize([line], font, bounds); + } + var encoded = font.encodeText(line); + var width = font.widthOfTextAtSize(line, fontSize); + var height = font.heightAtSize(fontSize, { descender: false }); + var x = alignment === TextAlignment.Left ? bounds.x : alignment === TextAlignment.Center ? bounds.x + bounds.width / 2 - width / 2 : alignment === TextAlignment.Right ? bounds.x + bounds.width - width : bounds.x; + var y = bounds.y + (bounds.height / 2 - height / 2); + return { + fontSize, + line: { text: line, encoded, width, height, x, y }, + bounds: { x, y, width, height } + }; +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/appearances.js +var normalizeAppearance = function(appearance) { + if ("normal" in appearance) + return appearance; + return { normal: appearance }; +}; +var tfRegex2 = /\/([^\0\t\n\f\r\ ]+)[\0\t\n\f\r\ ]+(\d*\.\d+|\d+)[\0\t\n\f\r\ ]+Tf/; +var getDefaultFontSize = function(field) { + var _a, _b; + var da = (_a = field.getDefaultAppearance()) !== null && _a !== void 0 ? _a : ""; + var daMatch = (_b = findLastMatch(da, tfRegex2).match) !== null && _b !== void 0 ? _b : []; + var defaultFontSize = Number(daMatch[2]); + return isFinite(defaultFontSize) ? defaultFontSize : void 0; +}; +var colorRegex = /(\d*\.\d+|\d+)[\0\t\n\f\r\ ]*(\d*\.\d+|\d+)?[\0\t\n\f\r\ ]*(\d*\.\d+|\d+)?[\0\t\n\f\r\ ]*(\d*\.\d+|\d+)?[\0\t\n\f\r\ ]+(g|rg|k)/; +var getDefaultColor = function(field) { + var _a; + var da = (_a = field.getDefaultAppearance()) !== null && _a !== void 0 ? _a : ""; + var daMatch = findLastMatch(da, colorRegex).match; + var _b = daMatch !== null && daMatch !== void 0 ? daMatch : [], c1 = _b[1], c2 = _b[2], c3 = _b[3], c4 = _b[4], colorSpace = _b[5]; + if (colorSpace === "g" && c1) { + return grayscale(Number(c1)); + } + if (colorSpace === "rg" && c1 && c2 && c3) { + return rgb(Number(c1), Number(c2), Number(c3)); + } + if (colorSpace === "k" && c1 && c2 && c3 && c4) { + return cmyk(Number(c1), Number(c2), Number(c3), Number(c4)); + } + return void 0; +}; +var updateDefaultAppearance = function(field, color, font, fontSize) { + var _a; + if (fontSize === void 0) { + fontSize = 0; + } + var da = [ + setFillingColor(color).toString(), + setFontAndSize((_a = font === null || font === void 0 ? void 0 : font.name) !== null && _a !== void 0 ? _a : "dummy__noop", fontSize).toString() + ].join("\n"); + field.setDefaultAppearance(da); +}; +var defaultCheckBoxAppearanceProvider = function(checkBox, widget) { + var _a, _b, _c; + var widgetColor = getDefaultColor(widget); + var fieldColor = getDefaultColor(checkBox.acroField); + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var _d = adjustDimsForRotation(rectangle, rotation), width = _d.width, height = _d.height; + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var black = rgb(0, 0, 0); + var borderColor = (_b = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor())) !== null && _b !== void 0 ? _b : black; + var normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor()); + var downBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor(), 0.8); + var textColor = (_c = widgetColor !== null && widgetColor !== void 0 ? widgetColor : fieldColor) !== null && _c !== void 0 ? _c : black; + if (widgetColor) { + updateDefaultAppearance(widget, textColor); + } else { + updateDefaultAppearance(checkBox.acroField, textColor); + } + var options = { + x: 0 + borderWidth / 2, + y: 0 + borderWidth / 2, + width: width - borderWidth, + height: height - borderWidth, + thickness: 1.5, + borderWidth, + borderColor, + markColor: textColor + }; + return { + normal: { + on: __spreadArrays(rotate, drawCheckBox(__assign(__assign({}, options), { color: normalBackgroundColor, filled: true }))), + off: __spreadArrays(rotate, drawCheckBox(__assign(__assign({}, options), { color: normalBackgroundColor, filled: false }))) + }, + down: { + on: __spreadArrays(rotate, drawCheckBox(__assign(__assign({}, options), { color: downBackgroundColor, filled: true }))), + off: __spreadArrays(rotate, drawCheckBox(__assign(__assign({}, options), { color: downBackgroundColor, filled: false }))) + } + }; +}; +var defaultRadioGroupAppearanceProvider = function(radioGroup, widget) { + var _a, _b, _c; + var widgetColor = getDefaultColor(widget); + var fieldColor = getDefaultColor(radioGroup.acroField); + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var _d = adjustDimsForRotation(rectangle, rotation), width = _d.width, height = _d.height; + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var black = rgb(0, 0, 0); + var borderColor = (_b = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor())) !== null && _b !== void 0 ? _b : black; + var normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor()); + var downBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor(), 0.8); + var textColor = (_c = widgetColor !== null && widgetColor !== void 0 ? widgetColor : fieldColor) !== null && _c !== void 0 ? _c : black; + if (widgetColor) { + updateDefaultAppearance(widget, textColor); + } else { + updateDefaultAppearance(radioGroup.acroField, textColor); + } + var options = { + x: width / 2, + y: height / 2, + width: width - borderWidth, + height: height - borderWidth, + borderWidth, + borderColor, + dotColor: textColor + }; + return { + normal: { + on: __spreadArrays(rotate, drawRadioButton(__assign(__assign({}, options), { color: normalBackgroundColor, filled: true }))), + off: __spreadArrays(rotate, drawRadioButton(__assign(__assign({}, options), { color: normalBackgroundColor, filled: false }))) + }, + down: { + on: __spreadArrays(rotate, drawRadioButton(__assign(__assign({}, options), { color: downBackgroundColor, filled: true }))), + off: __spreadArrays(rotate, drawRadioButton(__assign(__assign({}, options), { color: downBackgroundColor, filled: false }))) + } + }; +}; +var defaultButtonAppearanceProvider = function(button, widget, font) { + var _a, _b, _c, _d, _e; + var widgetColor = getDefaultColor(widget); + var fieldColor = getDefaultColor(button.acroField); + var widgetFontSize = getDefaultFontSize(widget); + var fieldFontSize = getDefaultFontSize(button.acroField); + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var captions = ap === null || ap === void 0 ? void 0 : ap.getCaptions(); + var normalText = (_a = captions === null || captions === void 0 ? void 0 : captions.normal) !== null && _a !== void 0 ? _a : ""; + var downText = (_c = (_b = captions === null || captions === void 0 ? void 0 : captions.down) !== null && _b !== void 0 ? _b : normalText) !== null && _c !== void 0 ? _c : ""; + var borderWidth = (_d = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _d !== void 0 ? _d : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var _f = adjustDimsForRotation(rectangle, rotation), width = _f.width, height = _f.height; + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var black = rgb(0, 0, 0); + var borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor()); + var normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor()); + var downBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor(), 0.8); + var bounds = { + x: borderWidth, + y: borderWidth, + width: width - borderWidth * 2, + height: height - borderWidth * 2 + }; + var normalLayout = layoutSinglelineText(normalText, { + alignment: TextAlignment.Center, + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds + }); + var downLayout = layoutSinglelineText(downText, { + alignment: TextAlignment.Center, + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds + }); + var fontSize = Math.min(normalLayout.fontSize, downLayout.fontSize); + var textColor = (_e = widgetColor !== null && widgetColor !== void 0 ? widgetColor : fieldColor) !== null && _e !== void 0 ? _e : black; + if (widgetColor || widgetFontSize !== void 0) { + updateDefaultAppearance(widget, textColor, font, fontSize); + } else { + updateDefaultAppearance(button.acroField, textColor, font, fontSize); + } + var options = { + x: 0 + borderWidth / 2, + y: 0 + borderWidth / 2, + width: width - borderWidth, + height: height - borderWidth, + borderWidth, + borderColor, + textColor, + font: font.name, + fontSize + }; + return { + normal: __spreadArrays(rotate, drawButton(__assign(__assign({}, options), { color: normalBackgroundColor, textLines: [normalLayout.line] }))), + down: __spreadArrays(rotate, drawButton(__assign(__assign({}, options), { color: downBackgroundColor, textLines: [downLayout.line] }))) + }; +}; +var defaultTextFieldAppearanceProvider = function(textField, widget, font) { + var _a, _b, _c, _d; + var widgetColor = getDefaultColor(widget); + var fieldColor = getDefaultColor(textField.acroField); + var widgetFontSize = getDefaultFontSize(widget); + var fieldFontSize = getDefaultFontSize(textField.acroField); + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var text = (_a = textField.getText()) !== null && _a !== void 0 ? _a : ""; + var borderWidth = (_b = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _b !== void 0 ? _b : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var _e = adjustDimsForRotation(rectangle, rotation), width = _e.width, height = _e.height; + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var black = rgb(0, 0, 0); + var borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor()); + var normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor()); + var textLines; + var fontSize; + var padding = textField.isCombed() ? 0 : 1; + var bounds = { + x: borderWidth + padding, + y: borderWidth + padding, + width: width - (borderWidth + padding) * 2, + height: height - (borderWidth + padding) * 2 + }; + if (textField.isMultiline()) { + var layout = layoutMultilineText(text, { + alignment: textField.getAlignment(), + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds + }); + textLines = layout.lines; + fontSize = layout.fontSize; + } else if (textField.isCombed()) { + var layout = layoutCombedText(text, { + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds, + cellCount: (_c = textField.getMaxLength()) !== null && _c !== void 0 ? _c : 0 + }); + textLines = layout.cells; + fontSize = layout.fontSize; + } else { + var layout = layoutSinglelineText(text, { + alignment: textField.getAlignment(), + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds + }); + textLines = [layout.line]; + fontSize = layout.fontSize; + } + var textColor = (_d = widgetColor !== null && widgetColor !== void 0 ? widgetColor : fieldColor) !== null && _d !== void 0 ? _d : black; + if (widgetColor || widgetFontSize !== void 0) { + updateDefaultAppearance(widget, textColor, font, fontSize); + } else { + updateDefaultAppearance(textField.acroField, textColor, font, fontSize); + } + var options = { + x: 0 + borderWidth / 2, + y: 0 + borderWidth / 2, + width: width - borderWidth, + height: height - borderWidth, + borderWidth: borderWidth !== null && borderWidth !== void 0 ? borderWidth : 0, + borderColor, + textColor, + font: font.name, + fontSize, + color: normalBackgroundColor, + textLines, + padding + }; + return __spreadArrays(rotate, drawTextField(options)); +}; +var defaultDropdownAppearanceProvider = function(dropdown, widget, font) { + var _a, _b, _c; + var widgetColor = getDefaultColor(widget); + var fieldColor = getDefaultColor(dropdown.acroField); + var widgetFontSize = getDefaultFontSize(widget); + var fieldFontSize = getDefaultFontSize(dropdown.acroField); + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var text = (_a = dropdown.getSelected()[0]) !== null && _a !== void 0 ? _a : ""; + var borderWidth = (_b = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _b !== void 0 ? _b : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var _d = adjustDimsForRotation(rectangle, rotation), width = _d.width, height = _d.height; + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var black = rgb(0, 0, 0); + var borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor()); + var normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor()); + var padding = 1; + var bounds = { + x: borderWidth + padding, + y: borderWidth + padding, + width: width - (borderWidth + padding) * 2, + height: height - (borderWidth + padding) * 2 + }; + var _e = layoutSinglelineText(text, { + alignment: TextAlignment.Left, + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds + }), line = _e.line, fontSize = _e.fontSize; + var textColor = (_c = widgetColor !== null && widgetColor !== void 0 ? widgetColor : fieldColor) !== null && _c !== void 0 ? _c : black; + if (widgetColor || widgetFontSize !== void 0) { + updateDefaultAppearance(widget, textColor, font, fontSize); + } else { + updateDefaultAppearance(dropdown.acroField, textColor, font, fontSize); + } + var options = { + x: 0 + borderWidth / 2, + y: 0 + borderWidth / 2, + width: width - borderWidth, + height: height - borderWidth, + borderWidth: borderWidth !== null && borderWidth !== void 0 ? borderWidth : 0, + borderColor, + textColor, + font: font.name, + fontSize, + color: normalBackgroundColor, + textLines: [line], + padding + }; + return __spreadArrays(rotate, drawTextField(options)); +}; +var defaultOptionListAppearanceProvider = function(optionList, widget, font) { + var _a, _b; + var widgetColor = getDefaultColor(widget); + var fieldColor = getDefaultColor(optionList.acroField); + var widgetFontSize = getDefaultFontSize(widget); + var fieldFontSize = getDefaultFontSize(optionList.acroField); + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var _c = adjustDimsForRotation(rectangle, rotation), width = _c.width, height = _c.height; + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var black = rgb(0, 0, 0); + var borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor()); + var normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor()); + var options = optionList.getOptions(); + var selected = optionList.getSelected(); + if (optionList.isSorted()) + options.sort(); + var text = ""; + for (var idx = 0, len = options.length; idx < len; idx++) { + text += options[idx]; + if (idx < len - 1) + text += "\n"; + } + var padding = 1; + var bounds = { + x: borderWidth + padding, + y: borderWidth + padding, + width: width - (borderWidth + padding) * 2, + height: height - (borderWidth + padding) * 2 + }; + var _d = layoutMultilineText(text, { + alignment: TextAlignment.Left, + fontSize: widgetFontSize !== null && widgetFontSize !== void 0 ? widgetFontSize : fieldFontSize, + font, + bounds + }), lines = _d.lines, fontSize = _d.fontSize, lineHeight = _d.lineHeight; + var selectedLines = []; + for (var idx = 0, len = lines.length; idx < len; idx++) { + var line = lines[idx]; + if (selected.includes(line.text)) + selectedLines.push(idx); + } + var blue = rgb(153 / 255, 193 / 255, 218 / 255); + var textColor = (_b = widgetColor !== null && widgetColor !== void 0 ? widgetColor : fieldColor) !== null && _b !== void 0 ? _b : black; + if (widgetColor || widgetFontSize !== void 0) { + updateDefaultAppearance(widget, textColor, font, fontSize); + } else { + updateDefaultAppearance(optionList.acroField, textColor, font, fontSize); + } + return __spreadArrays(rotate, drawOptionList({ + x: 0 + borderWidth / 2, + y: 0 + borderWidth / 2, + width: width - borderWidth, + height: height - borderWidth, + borderWidth: borderWidth !== null && borderWidth !== void 0 ? borderWidth : 0, + borderColor, + textColor, + font: font.name, + fontSize, + color: normalBackgroundColor, + textLines: lines, + lineHeight, + selectedColor: blue, + selectedLines, + padding + })); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFEmbeddedPage.js +var PDFEmbeddedPage = ( + /** @class */ + function() { + function PDFEmbeddedPage2(ref, doc, embedder) { + this.alreadyEmbedded = false; + assertIs(ref, "ref", [[PDFRef_default, "PDFRef"]]); + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + assertIs(embedder, "embedder", [[PDFPageEmbedder_default, "PDFPageEmbedder"]]); + this.ref = ref; + this.doc = doc; + this.width = embedder.width; + this.height = embedder.height; + this.embedder = embedder; + } + PDFEmbeddedPage2.prototype.scale = function(factor) { + assertIs(factor, "factor", ["number"]); + return { width: this.width * factor, height: this.height * factor }; + }; + PDFEmbeddedPage2.prototype.size = function() { + return this.scale(1); + }; + PDFEmbeddedPage2.prototype.embed = function() { + return __awaiter(this, void 0, void 0, function() { + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + if (!!this.alreadyEmbedded) return [3, 2]; + return [4, this.embedder.embedIntoContext(this.doc.context, this.ref)]; + case 1: + _a.sent(); + this.alreadyEmbedded = true; + _a.label = 2; + case 2: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFEmbeddedPage2.of = function(ref, doc, embedder) { + return new PDFEmbeddedPage2(ref, doc, embedder); + }; + return PDFEmbeddedPage2; + }() +); +var PDFEmbeddedPage_default = PDFEmbeddedPage; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFFont.js +var PDFFont = ( + /** @class */ + function() { + function PDFFont2(ref, doc, embedder) { + this.modified = true; + assertIs(ref, "ref", [[PDFRef_default, "PDFRef"]]); + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + assertIs(embedder, "embedder", [ + [CustomFontEmbedder_default, "CustomFontEmbedder"], + [StandardFontEmbedder_default, "StandardFontEmbedder"] + ]); + this.ref = ref; + this.doc = doc; + this.name = embedder.fontName; + this.embedder = embedder; + } + PDFFont2.prototype.encodeText = function(text) { + assertIs(text, "text", ["string"]); + this.modified = true; + return this.embedder.encodeText(text); + }; + PDFFont2.prototype.widthOfTextAtSize = function(text, size) { + assertIs(text, "text", ["string"]); + assertIs(size, "size", ["number"]); + return this.embedder.widthOfTextAtSize(text, size); + }; + PDFFont2.prototype.heightAtSize = function(size, options) { + var _a; + assertIs(size, "size", ["number"]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.descender, "options.descender", ["boolean"]); + return this.embedder.heightOfFontAtSize(size, { + descender: (_a = options === null || options === void 0 ? void 0 : options.descender) !== null && _a !== void 0 ? _a : true + }); + }; + PDFFont2.prototype.sizeAtHeight = function(height) { + assertIs(height, "height", ["number"]); + return this.embedder.sizeOfFontAtHeight(height); + }; + PDFFont2.prototype.getCharacterSet = function() { + if (this.embedder instanceof StandardFontEmbedder_default) { + return this.embedder.encoding.supportedCodePoints; + } else { + return this.embedder.font.characterSet; + } + }; + PDFFont2.prototype.embed = function() { + return __awaiter(this, void 0, void 0, function() { + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + if (!this.modified) return [3, 2]; + return [4, this.embedder.embedIntoContext(this.doc.context, this.ref)]; + case 1: + _a.sent(); + this.modified = false; + _a.label = 2; + case 2: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFFont2.of = function(ref, doc, embedder) { + return new PDFFont2(ref, doc, embedder); + }; + return PDFFont2; + }() +); +var PDFFont_default = PDFFont; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFImage.js +var PDFImage = ( + /** @class */ + function() { + function PDFImage2(ref, doc, embedder) { + assertIs(ref, "ref", [[PDFRef_default, "PDFRef"]]); + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + assertIs(embedder, "embedder", [ + [JpegEmbedder_default, "JpegEmbedder"], + [PngEmbedder_default, "PngEmbedder"] + ]); + this.ref = ref; + this.doc = doc; + this.width = embedder.width; + this.height = embedder.height; + this.embedder = embedder; + } + PDFImage2.prototype.scale = function(factor) { + assertIs(factor, "factor", ["number"]); + return { width: this.width * factor, height: this.height * factor }; + }; + PDFImage2.prototype.scaleToFit = function(width, height) { + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var imgWidthScale = width / this.width; + var imgHeightScale = height / this.height; + var scale2 = Math.min(imgWidthScale, imgHeightScale); + return this.scale(scale2); + }; + PDFImage2.prototype.size = function() { + return this.scale(1); + }; + PDFImage2.prototype.embed = function() { + return __awaiter(this, void 0, void 0, function() { + var _a, doc, ref; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + if (!this.embedder) + return [ + 2 + /*return*/ + ]; + if (!this.embedTask) { + _a = this, doc = _a.doc, ref = _a.ref; + this.embedTask = this.embedder.embedIntoContext(doc.context, ref); + } + return [4, this.embedTask]; + case 1: + _b.sent(); + this.embedder = void 0; + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFImage2.of = function(ref, doc, embedder) { + return new PDFImage2(ref, doc, embedder); + }; + return PDFImage2; + }() +); +var PDFImage_default = PDFImage; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/image/alignment.js +var ImageAlignment; +(function(ImageAlignment2) { + ImageAlignment2[ImageAlignment2["Left"] = 0] = "Left"; + ImageAlignment2[ImageAlignment2["Center"] = 1] = "Center"; + ImageAlignment2[ImageAlignment2["Right"] = 2] = "Right"; +})(ImageAlignment || (ImageAlignment = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFField.js +var assertFieldAppearanceOptions = function(options) { + assertOrUndefined(options === null || options === void 0 ? void 0 : options.x, "options.x", ["number"]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.y, "options.y", ["number"]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.width, "options.width", ["number"]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.height, "options.height", ["number"]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.textColor, "options.textColor", [ + [Object, "Color"] + ]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.backgroundColor, "options.backgroundColor", [ + [Object, "Color"] + ]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.borderColor, "options.borderColor", [ + [Object, "Color"] + ]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.borderWidth, "options.borderWidth", ["number"]); + assertOrUndefined(options === null || options === void 0 ? void 0 : options.rotate, "options.rotate", [[Object, "Rotation"]]); +}; +var PDFField = ( + /** @class */ + function() { + function PDFField2(acroField, ref, doc) { + assertIs(acroField, "acroField", [[PDFAcroTerminal_default, "PDFAcroTerminal"]]); + assertIs(ref, "ref", [[PDFRef_default, "PDFRef"]]); + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + this.acroField = acroField; + this.ref = ref; + this.doc = doc; + } + PDFField2.prototype.getName = function() { + var _a; + return (_a = this.acroField.getFullyQualifiedName()) !== null && _a !== void 0 ? _a : ""; + }; + PDFField2.prototype.isReadOnly = function() { + return this.acroField.hasFlag(AcroFieldFlags.ReadOnly); + }; + PDFField2.prototype.enableReadOnly = function() { + this.acroField.setFlagTo(AcroFieldFlags.ReadOnly, true); + }; + PDFField2.prototype.disableReadOnly = function() { + this.acroField.setFlagTo(AcroFieldFlags.ReadOnly, false); + }; + PDFField2.prototype.isRequired = function() { + return this.acroField.hasFlag(AcroFieldFlags.Required); + }; + PDFField2.prototype.enableRequired = function() { + this.acroField.setFlagTo(AcroFieldFlags.Required, true); + }; + PDFField2.prototype.disableRequired = function() { + this.acroField.setFlagTo(AcroFieldFlags.Required, false); + }; + PDFField2.prototype.isExported = function() { + return !this.acroField.hasFlag(AcroFieldFlags.NoExport); + }; + PDFField2.prototype.enableExporting = function() { + this.acroField.setFlagTo(AcroFieldFlags.NoExport, false); + }; + PDFField2.prototype.disableExporting = function() { + this.acroField.setFlagTo(AcroFieldFlags.NoExport, true); + }; + PDFField2.prototype.needsAppearancesUpdate = function() { + throw new MethodNotImplementedError(this.constructor.name, "needsAppearancesUpdate"); + }; + PDFField2.prototype.defaultUpdateAppearances = function(_font) { + throw new MethodNotImplementedError(this.constructor.name, "defaultUpdateAppearances"); + }; + PDFField2.prototype.markAsDirty = function() { + this.doc.getForm().markFieldAsDirty(this.ref); + }; + PDFField2.prototype.markAsClean = function() { + this.doc.getForm().markFieldAsClean(this.ref); + }; + PDFField2.prototype.isDirty = function() { + return this.doc.getForm().fieldIsDirty(this.ref); + }; + PDFField2.prototype.createWidget = function(options) { + var _a; + var textColor = options.textColor; + var backgroundColor = options.backgroundColor; + var borderColor = options.borderColor; + var borderWidth = options.borderWidth; + var degreesAngle = toDegrees(options.rotate); + var caption = options.caption; + var x = options.x; + var y = options.y; + var width = options.width + borderWidth; + var height = options.height + borderWidth; + var hidden = Boolean(options.hidden); + var pageRef = options.page; + assertMultiple(degreesAngle, "degreesAngle", 90); + var widget = PDFWidgetAnnotation_default.create(this.doc.context, this.ref); + var rect = rotateRectangle({ x, y, width, height }, borderWidth, degreesAngle); + widget.setRectangle(rect); + if (pageRef) + widget.setP(pageRef); + var ac = widget.getOrCreateAppearanceCharacteristics(); + if (backgroundColor) { + ac.setBackgroundColor(colorToComponents(backgroundColor)); + } + ac.setRotation(degreesAngle); + if (caption) + ac.setCaptions({ normal: caption }); + if (borderColor) + ac.setBorderColor(colorToComponents(borderColor)); + var bs = widget.getOrCreateBorderStyle(); + if (borderWidth !== void 0) + bs.setWidth(borderWidth); + widget.setFlagTo(AnnotationFlags.Print, true); + widget.setFlagTo(AnnotationFlags.Hidden, hidden); + widget.setFlagTo(AnnotationFlags.Invisible, false); + if (textColor) { + var da = (_a = this.acroField.getDefaultAppearance()) !== null && _a !== void 0 ? _a : ""; + var newDa = da + "\n" + setFillingColor(textColor).toString(); + this.acroField.setDefaultAppearance(newDa); + } + return widget; + }; + PDFField2.prototype.updateWidgetAppearanceWithFont = function(widget, font, _a) { + var normal = _a.normal, rollover = _a.rollover, down = _a.down; + this.updateWidgetAppearances(widget, { + normal: this.createAppearanceStream(widget, normal, font), + rollover: rollover && this.createAppearanceStream(widget, rollover, font), + down: down && this.createAppearanceStream(widget, down, font) + }); + }; + PDFField2.prototype.updateOnOffWidgetAppearance = function(widget, onValue, _a) { + var normal = _a.normal, rollover = _a.rollover, down = _a.down; + this.updateWidgetAppearances(widget, { + normal: this.createAppearanceDict(widget, normal, onValue), + rollover: rollover && this.createAppearanceDict(widget, rollover, onValue), + down: down && this.createAppearanceDict(widget, down, onValue) + }); + }; + PDFField2.prototype.updateWidgetAppearances = function(widget, _a) { + var normal = _a.normal, rollover = _a.rollover, down = _a.down; + widget.setNormalAppearance(normal); + if (rollover) { + widget.setRolloverAppearance(rollover); + } else { + widget.removeRolloverAppearance(); + } + if (down) { + widget.setDownAppearance(down); + } else { + widget.removeDownAppearance(); + } + }; + PDFField2.prototype.createAppearanceStream = function(widget, appearance, font) { + var _a; + var context = this.acroField.dict.context; + var _b = widget.getRectangle(), width = _b.width, height = _b.height; + var Resources = font && { Font: (_a = {}, _a[font.name] = font.ref, _a) }; + var stream2 = context.formXObject(appearance, { + Resources, + BBox: context.obj([0, 0, width, height]), + Matrix: context.obj([1, 0, 0, 1, 0, 0]) + }); + var streamRef = context.register(stream2); + return streamRef; + }; + PDFField2.prototype.createImageAppearanceStream = function(widget, image, alignment) { + var _a; + var _b; + var context = this.acroField.dict.context; + var rectangle = widget.getRectangle(); + var ap = widget.getAppearanceCharacteristics(); + var bs = widget.getBorderStyle(); + var borderWidth = (_b = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _b !== void 0 ? _b : 0; + var rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation()); + var rotate = rotateInPlace(__assign(__assign({}, rectangle), { rotation })); + var adj = adjustDimsForRotation(rectangle, rotation); + var imageDims = image.scaleToFit(adj.width - borderWidth * 2, adj.height - borderWidth * 2); + var options = { + x: borderWidth, + y: borderWidth, + width: imageDims.width, + height: imageDims.height, + // + rotate: degrees(0), + xSkew: degrees(0), + ySkew: degrees(0) + }; + if (alignment === ImageAlignment.Center) { + options.x += (adj.width - borderWidth * 2) / 2 - imageDims.width / 2; + options.y += (adj.height - borderWidth * 2) / 2 - imageDims.height / 2; + } else if (alignment === ImageAlignment.Right) { + options.x = adj.width - borderWidth - imageDims.width; + options.y = adj.height - borderWidth - imageDims.height; + } + var imageName = this.doc.context.addRandomSuffix("Image", 10); + var appearance = __spreadArrays(rotate, drawImage(imageName, options)); + var Resources = { XObject: (_a = {}, _a[imageName] = image.ref, _a) }; + var stream2 = context.formXObject(appearance, { + Resources, + BBox: context.obj([0, 0, rectangle.width, rectangle.height]), + Matrix: context.obj([1, 0, 0, 1, 0, 0]) + }); + return context.register(stream2); + }; + PDFField2.prototype.createAppearanceDict = function(widget, appearance, onValue) { + var context = this.acroField.dict.context; + var onStreamRef = this.createAppearanceStream(widget, appearance.on); + var offStreamRef = this.createAppearanceStream(widget, appearance.off); + var appearanceDict = context.obj({}); + appearanceDict.set(onValue, onStreamRef); + appearanceDict.set(PDFName_default.of("Off"), offStreamRef); + return appearanceDict; + }; + return PDFField2; + }() +); +var PDFField_default = PDFField; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFCheckBox.js +var PDFCheckBox = ( + /** @class */ + function(_super) { + __extends(PDFCheckBox2, _super); + function PDFCheckBox2(acroCheckBox, ref, doc) { + var _this = _super.call(this, acroCheckBox, ref, doc) || this; + assertIs(acroCheckBox, "acroCheckBox", [ + [PDFAcroCheckBox_default, "PDFAcroCheckBox"] + ]); + _this.acroField = acroCheckBox; + return _this; + } + PDFCheckBox2.prototype.check = function() { + var _a; + var onValue = (_a = this.acroField.getOnValue()) !== null && _a !== void 0 ? _a : PDFName_default.of("Yes"); + this.markAsDirty(); + this.acroField.setValue(onValue); + }; + PDFCheckBox2.prototype.uncheck = function() { + this.markAsDirty(); + this.acroField.setValue(PDFName_default.of("Off")); + }; + PDFCheckBox2.prototype.isChecked = function() { + var onValue = this.acroField.getOnValue(); + return !!onValue && onValue === this.acroField.getValue(); + }; + PDFCheckBox2.prototype.addToPage = function(page, options) { + var _a, _b, _c, _d, _e, _f; + assertIs(page, "page", [[PDFPage_default, "PDFPage"]]); + assertFieldAppearanceOptions(options); + if (!options) + options = {}; + if (!("textColor" in options)) + options.textColor = rgb(0, 0, 0); + if (!("backgroundColor" in options)) + options.backgroundColor = rgb(1, 1, 1); + if (!("borderColor" in options)) + options.borderColor = rgb(0, 0, 0); + if (!("borderWidth" in options)) + options.borderWidth = 1; + var widget = this.createWidget({ + x: (_a = options.x) !== null && _a !== void 0 ? _a : 0, + y: (_b = options.y) !== null && _b !== void 0 ? _b : 0, + width: (_c = options.width) !== null && _c !== void 0 ? _c : 50, + height: (_d = options.height) !== null && _d !== void 0 ? _d : 50, + textColor: options.textColor, + backgroundColor: options.backgroundColor, + borderColor: options.borderColor, + borderWidth: (_e = options.borderWidth) !== null && _e !== void 0 ? _e : 0, + rotate: (_f = options.rotate) !== null && _f !== void 0 ? _f : degrees(0), + hidden: options.hidden, + page: page.ref + }); + var widgetRef = this.doc.context.register(widget.dict); + this.acroField.addWidget(widgetRef); + widget.setAppearanceState(PDFName_default.of("Off")); + this.updateWidgetAppearance(widget, PDFName_default.of("Yes")); + page.node.addAnnot(widgetRef); + }; + PDFCheckBox2.prototype.needsAppearancesUpdate = function() { + var _a; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var state = widget.getAppearanceState(); + var normal = (_a = widget.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal; + if (!(normal instanceof PDFDict_default)) + return true; + if (state && !normal.has(state)) + return true; + } + return false; + }; + PDFCheckBox2.prototype.defaultUpdateAppearances = function() { + this.updateAppearances(); + }; + PDFCheckBox2.prototype.updateAppearances = function(provider) { + var _a; + assertOrUndefined(provider, "provider", [Function]); + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var onValue = (_a = widget.getOnValue()) !== null && _a !== void 0 ? _a : PDFName_default.of("Yes"); + if (!onValue) + continue; + this.updateWidgetAppearance(widget, onValue, provider); + } + this.markAsClean(); + }; + PDFCheckBox2.prototype.updateWidgetAppearance = function(widget, onValue, provider) { + var apProvider = provider !== null && provider !== void 0 ? provider : defaultCheckBoxAppearanceProvider; + var appearances = normalizeAppearance(apProvider(this, widget)); + this.updateOnOffWidgetAppearance(widget, onValue, appearances); + }; + PDFCheckBox2.of = function(acroCheckBox, ref, doc) { + return new PDFCheckBox2(acroCheckBox, ref, doc); + }; + return PDFCheckBox2; + }(PDFField_default) +); +var PDFCheckBox_default = PDFCheckBox; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFDropdown.js +var PDFDropdown = ( + /** @class */ + function(_super) { + __extends(PDFDropdown2, _super); + function PDFDropdown2(acroComboBox, ref, doc) { + var _this = _super.call(this, acroComboBox, ref, doc) || this; + assertIs(acroComboBox, "acroComboBox", [ + [PDFAcroComboBox_default, "PDFAcroComboBox"] + ]); + _this.acroField = acroComboBox; + return _this; + } + PDFDropdown2.prototype.getOptions = function() { + var rawOptions = this.acroField.getOptions(); + var options = new Array(rawOptions.length); + for (var idx = 0, len = options.length; idx < len; idx++) { + var _a = rawOptions[idx], display = _a.display, value = _a.value; + options[idx] = (display !== null && display !== void 0 ? display : value).decodeText(); + } + return options; + }; + PDFDropdown2.prototype.getSelected = function() { + var values2 = this.acroField.getValues(); + var selected = new Array(values2.length); + for (var idx = 0, len = values2.length; idx < len; idx++) { + selected[idx] = values2[idx].decodeText(); + } + return selected; + }; + PDFDropdown2.prototype.setOptions = function(options) { + assertIs(options, "options", [Array]); + var optionObjects = new Array(options.length); + for (var idx = 0, len = options.length; idx < len; idx++) { + optionObjects[idx] = { value: PDFHexString_default.fromText(options[idx]) }; + } + this.acroField.setOptions(optionObjects); + }; + PDFDropdown2.prototype.addOptions = function(options) { + assertIs(options, "options", ["string", Array]); + var optionsArr = Array.isArray(options) ? options : [options]; + var existingOptions = this.acroField.getOptions(); + var newOptions = new Array(optionsArr.length); + for (var idx = 0, len = optionsArr.length; idx < len; idx++) { + newOptions[idx] = { value: PDFHexString_default.fromText(optionsArr[idx]) }; + } + this.acroField.setOptions(existingOptions.concat(newOptions)); + }; + PDFDropdown2.prototype.select = function(options, merge2) { + if (merge2 === void 0) { + merge2 = false; + } + assertIs(options, "options", ["string", Array]); + assertIs(merge2, "merge", ["boolean"]); + var optionsArr = Array.isArray(options) ? options : [options]; + var validOptions = this.getOptions(); + var hasCustomOption = optionsArr.find(function(option) { + return !validOptions.includes(option); + }); + if (hasCustomOption) + this.enableEditing(); + this.markAsDirty(); + if (optionsArr.length > 1 || optionsArr.length === 1 && merge2) { + this.enableMultiselect(); + } + var values2 = new Array(optionsArr.length); + for (var idx = 0, len = optionsArr.length; idx < len; idx++) { + values2[idx] = PDFHexString_default.fromText(optionsArr[idx]); + } + if (merge2) { + var existingValues = this.acroField.getValues(); + this.acroField.setValues(existingValues.concat(values2)); + } else { + this.acroField.setValues(values2); + } + }; + PDFDropdown2.prototype.clear = function() { + this.markAsDirty(); + this.acroField.setValues([]); + }; + PDFDropdown2.prototype.setFontSize = function(fontSize) { + assertPositive(fontSize, "fontSize"); + this.acroField.setFontSize(fontSize); + this.markAsDirty(); + }; + PDFDropdown2.prototype.isEditable = function() { + return this.acroField.hasFlag(AcroChoiceFlags.Edit); + }; + PDFDropdown2.prototype.enableEditing = function() { + this.acroField.setFlagTo(AcroChoiceFlags.Edit, true); + }; + PDFDropdown2.prototype.disableEditing = function() { + this.acroField.setFlagTo(AcroChoiceFlags.Edit, false); + }; + PDFDropdown2.prototype.isSorted = function() { + return this.acroField.hasFlag(AcroChoiceFlags.Sort); + }; + PDFDropdown2.prototype.enableSorting = function() { + this.acroField.setFlagTo(AcroChoiceFlags.Sort, true); + }; + PDFDropdown2.prototype.disableSorting = function() { + this.acroField.setFlagTo(AcroChoiceFlags.Sort, false); + }; + PDFDropdown2.prototype.isMultiselect = function() { + return this.acroField.hasFlag(AcroChoiceFlags.MultiSelect); + }; + PDFDropdown2.prototype.enableMultiselect = function() { + this.acroField.setFlagTo(AcroChoiceFlags.MultiSelect, true); + }; + PDFDropdown2.prototype.disableMultiselect = function() { + this.acroField.setFlagTo(AcroChoiceFlags.MultiSelect, false); + }; + PDFDropdown2.prototype.isSpellChecked = function() { + return !this.acroField.hasFlag(AcroChoiceFlags.DoNotSpellCheck); + }; + PDFDropdown2.prototype.enableSpellChecking = function() { + this.acroField.setFlagTo(AcroChoiceFlags.DoNotSpellCheck, false); + }; + PDFDropdown2.prototype.disableSpellChecking = function() { + this.acroField.setFlagTo(AcroChoiceFlags.DoNotSpellCheck, true); + }; + PDFDropdown2.prototype.isSelectOnClick = function() { + return this.acroField.hasFlag(AcroChoiceFlags.CommitOnSelChange); + }; + PDFDropdown2.prototype.enableSelectOnClick = function() { + this.acroField.setFlagTo(AcroChoiceFlags.CommitOnSelChange, true); + }; + PDFDropdown2.prototype.disableSelectOnClick = function() { + this.acroField.setFlagTo(AcroChoiceFlags.CommitOnSelChange, false); + }; + PDFDropdown2.prototype.addToPage = function(page, options) { + var _a, _b, _c, _d, _e, _f, _g; + assertIs(page, "page", [[PDFPage_default, "PDFPage"]]); + assertFieldAppearanceOptions(options); + if (!options) + options = {}; + if (!("textColor" in options)) + options.textColor = rgb(0, 0, 0); + if (!("backgroundColor" in options)) + options.backgroundColor = rgb(1, 1, 1); + if (!("borderColor" in options)) + options.borderColor = rgb(0, 0, 0); + if (!("borderWidth" in options)) + options.borderWidth = 1; + var widget = this.createWidget({ + x: (_a = options.x) !== null && _a !== void 0 ? _a : 0, + y: (_b = options.y) !== null && _b !== void 0 ? _b : 0, + width: (_c = options.width) !== null && _c !== void 0 ? _c : 200, + height: (_d = options.height) !== null && _d !== void 0 ? _d : 50, + textColor: options.textColor, + backgroundColor: options.backgroundColor, + borderColor: options.borderColor, + borderWidth: (_e = options.borderWidth) !== null && _e !== void 0 ? _e : 0, + rotate: (_f = options.rotate) !== null && _f !== void 0 ? _f : degrees(0), + hidden: options.hidden, + page: page.ref + }); + var widgetRef = this.doc.context.register(widget.dict); + this.acroField.addWidget(widgetRef); + var font = (_g = options.font) !== null && _g !== void 0 ? _g : this.doc.getForm().getDefaultFont(); + this.updateWidgetAppearance(widget, font); + page.node.addAnnot(widgetRef); + }; + PDFDropdown2.prototype.needsAppearancesUpdate = function() { + var _a; + if (this.isDirty()) + return true; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var hasAppearances = ((_a = widget.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal) instanceof PDFStream_default; + if (!hasAppearances) + return true; + } + return false; + }; + PDFDropdown2.prototype.defaultUpdateAppearances = function(font) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + this.updateAppearances(font); + }; + PDFDropdown2.prototype.updateAppearances = function(font, provider) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + assertOrUndefined(provider, "provider", [Function]); + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + this.updateWidgetAppearance(widget, font, provider); + } + this.markAsClean(); + }; + PDFDropdown2.prototype.updateWidgetAppearance = function(widget, font, provider) { + var apProvider = provider !== null && provider !== void 0 ? provider : defaultDropdownAppearanceProvider; + var appearances = normalizeAppearance(apProvider(this, widget, font)); + this.updateWidgetAppearanceWithFont(widget, font, appearances); + }; + PDFDropdown2.of = function(acroComboBox, ref, doc) { + return new PDFDropdown2(acroComboBox, ref, doc); + }; + return PDFDropdown2; + }(PDFField_default) +); +var PDFDropdown_default = PDFDropdown; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFOptionList.js +var PDFOptionList = ( + /** @class */ + function(_super) { + __extends(PDFOptionList2, _super); + function PDFOptionList2(acroListBox, ref, doc) { + var _this = _super.call(this, acroListBox, ref, doc) || this; + assertIs(acroListBox, "acroListBox", [[PDFAcroListBox_default, "PDFAcroListBox"]]); + _this.acroField = acroListBox; + return _this; + } + PDFOptionList2.prototype.getOptions = function() { + var rawOptions = this.acroField.getOptions(); + var options = new Array(rawOptions.length); + for (var idx = 0, len = options.length; idx < len; idx++) { + var _a = rawOptions[idx], display = _a.display, value = _a.value; + options[idx] = (display !== null && display !== void 0 ? display : value).decodeText(); + } + return options; + }; + PDFOptionList2.prototype.getSelected = function() { + var values2 = this.acroField.getValues(); + var selected = new Array(values2.length); + for (var idx = 0, len = values2.length; idx < len; idx++) { + selected[idx] = values2[idx].decodeText(); + } + return selected; + }; + PDFOptionList2.prototype.setOptions = function(options) { + assertIs(options, "options", [Array]); + this.markAsDirty(); + var optionObjects = new Array(options.length); + for (var idx = 0, len = options.length; idx < len; idx++) { + optionObjects[idx] = { value: PDFHexString_default.fromText(options[idx]) }; + } + this.acroField.setOptions(optionObjects); + }; + PDFOptionList2.prototype.addOptions = function(options) { + assertIs(options, "options", ["string", Array]); + this.markAsDirty(); + var optionsArr = Array.isArray(options) ? options : [options]; + var existingOptions = this.acroField.getOptions(); + var newOptions = new Array(optionsArr.length); + for (var idx = 0, len = optionsArr.length; idx < len; idx++) { + newOptions[idx] = { value: PDFHexString_default.fromText(optionsArr[idx]) }; + } + this.acroField.setOptions(existingOptions.concat(newOptions)); + }; + PDFOptionList2.prototype.select = function(options, merge2) { + if (merge2 === void 0) { + merge2 = false; + } + assertIs(options, "options", ["string", Array]); + assertIs(merge2, "merge", ["boolean"]); + var optionsArr = Array.isArray(options) ? options : [options]; + var validOptions = this.getOptions(); + assertIsSubset(optionsArr, "option", validOptions); + this.markAsDirty(); + if (optionsArr.length > 1 || optionsArr.length === 1 && merge2) { + this.enableMultiselect(); + } + var values2 = new Array(optionsArr.length); + for (var idx = 0, len = optionsArr.length; idx < len; idx++) { + values2[idx] = PDFHexString_default.fromText(optionsArr[idx]); + } + if (merge2) { + var existingValues = this.acroField.getValues(); + this.acroField.setValues(existingValues.concat(values2)); + } else { + this.acroField.setValues(values2); + } + }; + PDFOptionList2.prototype.clear = function() { + this.markAsDirty(); + this.acroField.setValues([]); + }; + PDFOptionList2.prototype.setFontSize = function(fontSize) { + assertPositive(fontSize, "fontSize"); + this.acroField.setFontSize(fontSize); + this.markAsDirty(); + }; + PDFOptionList2.prototype.isSorted = function() { + return this.acroField.hasFlag(AcroChoiceFlags.Sort); + }; + PDFOptionList2.prototype.enableSorting = function() { + this.acroField.setFlagTo(AcroChoiceFlags.Sort, true); + }; + PDFOptionList2.prototype.disableSorting = function() { + this.acroField.setFlagTo(AcroChoiceFlags.Sort, false); + }; + PDFOptionList2.prototype.isMultiselect = function() { + return this.acroField.hasFlag(AcroChoiceFlags.MultiSelect); + }; + PDFOptionList2.prototype.enableMultiselect = function() { + this.acroField.setFlagTo(AcroChoiceFlags.MultiSelect, true); + }; + PDFOptionList2.prototype.disableMultiselect = function() { + this.acroField.setFlagTo(AcroChoiceFlags.MultiSelect, false); + }; + PDFOptionList2.prototype.isSelectOnClick = function() { + return this.acroField.hasFlag(AcroChoiceFlags.CommitOnSelChange); + }; + PDFOptionList2.prototype.enableSelectOnClick = function() { + this.acroField.setFlagTo(AcroChoiceFlags.CommitOnSelChange, true); + }; + PDFOptionList2.prototype.disableSelectOnClick = function() { + this.acroField.setFlagTo(AcroChoiceFlags.CommitOnSelChange, false); + }; + PDFOptionList2.prototype.addToPage = function(page, options) { + var _a, _b, _c, _d, _e, _f, _g; + assertIs(page, "page", [[PDFPage_default, "PDFPage"]]); + assertFieldAppearanceOptions(options); + if (!options) + options = {}; + if (!("textColor" in options)) + options.textColor = rgb(0, 0, 0); + if (!("backgroundColor" in options)) + options.backgroundColor = rgb(1, 1, 1); + if (!("borderColor" in options)) + options.borderColor = rgb(0, 0, 0); + if (!("borderWidth" in options)) + options.borderWidth = 1; + var widget = this.createWidget({ + x: (_a = options.x) !== null && _a !== void 0 ? _a : 0, + y: (_b = options.y) !== null && _b !== void 0 ? _b : 0, + width: (_c = options.width) !== null && _c !== void 0 ? _c : 200, + height: (_d = options.height) !== null && _d !== void 0 ? _d : 100, + textColor: options.textColor, + backgroundColor: options.backgroundColor, + borderColor: options.borderColor, + borderWidth: (_e = options.borderWidth) !== null && _e !== void 0 ? _e : 0, + rotate: (_f = options.rotate) !== null && _f !== void 0 ? _f : degrees(0), + hidden: options.hidden, + page: page.ref + }); + var widgetRef = this.doc.context.register(widget.dict); + this.acroField.addWidget(widgetRef); + var font = (_g = options.font) !== null && _g !== void 0 ? _g : this.doc.getForm().getDefaultFont(); + this.updateWidgetAppearance(widget, font); + page.node.addAnnot(widgetRef); + }; + PDFOptionList2.prototype.needsAppearancesUpdate = function() { + var _a; + if (this.isDirty()) + return true; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var hasAppearances = ((_a = widget.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal) instanceof PDFStream_default; + if (!hasAppearances) + return true; + } + return false; + }; + PDFOptionList2.prototype.defaultUpdateAppearances = function(font) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + this.updateAppearances(font); + }; + PDFOptionList2.prototype.updateAppearances = function(font, provider) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + assertOrUndefined(provider, "provider", [Function]); + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + this.updateWidgetAppearance(widget, font, provider); + } + this.markAsClean(); + }; + PDFOptionList2.prototype.updateWidgetAppearance = function(widget, font, provider) { + var apProvider = provider !== null && provider !== void 0 ? provider : defaultOptionListAppearanceProvider; + var appearances = normalizeAppearance(apProvider(this, widget, font)); + this.updateWidgetAppearanceWithFont(widget, font, appearances); + }; + PDFOptionList2.of = function(acroListBox, ref, doc) { + return new PDFOptionList2(acroListBox, ref, doc); + }; + return PDFOptionList2; + }(PDFField_default) +); +var PDFOptionList_default = PDFOptionList; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFRadioGroup.js +var PDFRadioGroup = ( + /** @class */ + function(_super) { + __extends(PDFRadioGroup2, _super); + function PDFRadioGroup2(acroRadioButton, ref, doc) { + var _this = _super.call(this, acroRadioButton, ref, doc) || this; + assertIs(acroRadioButton, "acroRadioButton", [ + [PDFAcroRadioButton_default, "PDFAcroRadioButton"] + ]); + _this.acroField = acroRadioButton; + return _this; + } + PDFRadioGroup2.prototype.getOptions = function() { + var exportValues = this.acroField.getExportValues(); + if (exportValues) { + var exportOptions = new Array(exportValues.length); + for (var idx = 0, len = exportValues.length; idx < len; idx++) { + exportOptions[idx] = exportValues[idx].decodeText(); + } + return exportOptions; + } + var onValues = this.acroField.getOnValues(); + var onOptions = new Array(onValues.length); + for (var idx = 0, len = onOptions.length; idx < len; idx++) { + onOptions[idx] = onValues[idx].decodeText(); + } + return onOptions; + }; + PDFRadioGroup2.prototype.getSelected = function() { + var value = this.acroField.getValue(); + if (value === PDFName_default.of("Off")) + return void 0; + var exportValues = this.acroField.getExportValues(); + if (exportValues) { + var onValues = this.acroField.getOnValues(); + for (var idx = 0, len = onValues.length; idx < len; idx++) { + if (onValues[idx] === value) + return exportValues[idx].decodeText(); + } + } + return value.decodeText(); + }; + PDFRadioGroup2.prototype.select = function(option) { + assertIs(option, "option", ["string"]); + var validOptions = this.getOptions(); + assertIsOneOf(option, "option", validOptions); + this.markAsDirty(); + var onValues = this.acroField.getOnValues(); + var exportValues = this.acroField.getExportValues(); + if (exportValues) { + for (var idx = 0, len = exportValues.length; idx < len; idx++) { + if (exportValues[idx].decodeText() === option) { + this.acroField.setValue(onValues[idx]); + } + } + } else { + for (var idx = 0, len = onValues.length; idx < len; idx++) { + var value = onValues[idx]; + if (value.decodeText() === option) + this.acroField.setValue(value); + } + } + }; + PDFRadioGroup2.prototype.clear = function() { + this.markAsDirty(); + this.acroField.setValue(PDFName_default.of("Off")); + }; + PDFRadioGroup2.prototype.isOffToggleable = function() { + return !this.acroField.hasFlag(AcroButtonFlags.NoToggleToOff); + }; + PDFRadioGroup2.prototype.enableOffToggling = function() { + this.acroField.setFlagTo(AcroButtonFlags.NoToggleToOff, false); + }; + PDFRadioGroup2.prototype.disableOffToggling = function() { + this.acroField.setFlagTo(AcroButtonFlags.NoToggleToOff, true); + }; + PDFRadioGroup2.prototype.isMutuallyExclusive = function() { + return !this.acroField.hasFlag(AcroButtonFlags.RadiosInUnison); + }; + PDFRadioGroup2.prototype.enableMutualExclusion = function() { + this.acroField.setFlagTo(AcroButtonFlags.RadiosInUnison, false); + }; + PDFRadioGroup2.prototype.disableMutualExclusion = function() { + this.acroField.setFlagTo(AcroButtonFlags.RadiosInUnison, true); + }; + PDFRadioGroup2.prototype.addOptionToPage = function(option, page, options) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j; + assertIs(option, "option", ["string"]); + assertIs(page, "page", [[PDFPage_default, "PDFPage"]]); + assertFieldAppearanceOptions(options); + var widget = this.createWidget({ + x: (_a = options === null || options === void 0 ? void 0 : options.x) !== null && _a !== void 0 ? _a : 0, + y: (_b = options === null || options === void 0 ? void 0 : options.y) !== null && _b !== void 0 ? _b : 0, + width: (_c = options === null || options === void 0 ? void 0 : options.width) !== null && _c !== void 0 ? _c : 50, + height: (_d = options === null || options === void 0 ? void 0 : options.height) !== null && _d !== void 0 ? _d : 50, + textColor: (_e = options === null || options === void 0 ? void 0 : options.textColor) !== null && _e !== void 0 ? _e : rgb(0, 0, 0), + backgroundColor: (_f = options === null || options === void 0 ? void 0 : options.backgroundColor) !== null && _f !== void 0 ? _f : rgb(1, 1, 1), + borderColor: (_g = options === null || options === void 0 ? void 0 : options.borderColor) !== null && _g !== void 0 ? _g : rgb(0, 0, 0), + borderWidth: (_h = options === null || options === void 0 ? void 0 : options.borderWidth) !== null && _h !== void 0 ? _h : 1, + rotate: (_j = options === null || options === void 0 ? void 0 : options.rotate) !== null && _j !== void 0 ? _j : degrees(0), + hidden: options === null || options === void 0 ? void 0 : options.hidden, + page: page.ref + }); + var widgetRef = this.doc.context.register(widget.dict); + var apStateValue = this.acroField.addWidgetWithOpt(widgetRef, PDFHexString_default.fromText(option), !this.isMutuallyExclusive()); + widget.setAppearanceState(PDFName_default.of("Off")); + this.updateWidgetAppearance(widget, apStateValue); + page.node.addAnnot(widgetRef); + }; + PDFRadioGroup2.prototype.needsAppearancesUpdate = function() { + var _a; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var state = widget.getAppearanceState(); + var normal = (_a = widget.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal; + if (!(normal instanceof PDFDict_default)) + return true; + if (state && !normal.has(state)) + return true; + } + return false; + }; + PDFRadioGroup2.prototype.defaultUpdateAppearances = function() { + this.updateAppearances(); + }; + PDFRadioGroup2.prototype.updateAppearances = function(provider) { + assertOrUndefined(provider, "provider", [Function]); + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var onValue = widget.getOnValue(); + if (!onValue) + continue; + this.updateWidgetAppearance(widget, onValue, provider); + } + }; + PDFRadioGroup2.prototype.updateWidgetAppearance = function(widget, onValue, provider) { + var apProvider = provider !== null && provider !== void 0 ? provider : defaultRadioGroupAppearanceProvider; + var appearances = normalizeAppearance(apProvider(this, widget)); + this.updateOnOffWidgetAppearance(widget, onValue, appearances); + }; + PDFRadioGroup2.of = function(acroRadioButton, ref, doc) { + return new PDFRadioGroup2(acroRadioButton, ref, doc); + }; + return PDFRadioGroup2; + }(PDFField_default) +); +var PDFRadioGroup_default = PDFRadioGroup; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFSignature.js +var PDFSignature = ( + /** @class */ + function(_super) { + __extends(PDFSignature2, _super); + function PDFSignature2(acroSignature, ref, doc) { + var _this = _super.call(this, acroSignature, ref, doc) || this; + assertIs(acroSignature, "acroSignature", [ + [PDFAcroSignature_default, "PDFAcroSignature"] + ]); + _this.acroField = acroSignature; + return _this; + } + PDFSignature2.prototype.needsAppearancesUpdate = function() { + return false; + }; + PDFSignature2.of = function(acroSignature, ref, doc) { + return new PDFSignature2(acroSignature, ref, doc); + }; + return PDFSignature2; + }(PDFField_default) +); +var PDFSignature_default = PDFSignature; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFTextField.js +var PDFTextField = ( + /** @class */ + function(_super) { + __extends(PDFTextField2, _super); + function PDFTextField2(acroText, ref, doc) { + var _this = _super.call(this, acroText, ref, doc) || this; + assertIs(acroText, "acroText", [[PDFAcroText_default, "PDFAcroText"]]); + _this.acroField = acroText; + return _this; + } + PDFTextField2.prototype.getText = function() { + var value = this.acroField.getValue(); + if (!value && this.isRichFormatted()) { + throw new RichTextFieldReadError(this.getName()); + } + return value === null || value === void 0 ? void 0 : value.decodeText(); + }; + PDFTextField2.prototype.setText = function(text) { + assertOrUndefined(text, "text", ["string"]); + var maxLength = this.getMaxLength(); + if (maxLength !== void 0 && text && text.length > maxLength) { + throw new ExceededMaxLengthError(text.length, maxLength, this.getName()); + } + this.markAsDirty(); + this.disableRichFormatting(); + if (text) { + this.acroField.setValue(PDFHexString_default.fromText(text)); + } else { + this.acroField.removeValue(); + } + }; + PDFTextField2.prototype.getAlignment = function() { + var quadding = this.acroField.getQuadding(); + return quadding === 0 ? TextAlignment.Left : quadding === 1 ? TextAlignment.Center : quadding === 2 ? TextAlignment.Right : TextAlignment.Left; + }; + PDFTextField2.prototype.setAlignment = function(alignment) { + assertIsOneOf(alignment, "alignment", TextAlignment); + this.markAsDirty(); + this.acroField.setQuadding(alignment); + }; + PDFTextField2.prototype.getMaxLength = function() { + return this.acroField.getMaxLength(); + }; + PDFTextField2.prototype.setMaxLength = function(maxLength) { + assertRangeOrUndefined(maxLength, "maxLength", 0, Number.MAX_SAFE_INTEGER); + this.markAsDirty(); + if (maxLength === void 0) { + this.acroField.removeMaxLength(); + } else { + var text = this.getText(); + if (text && text.length > maxLength) { + throw new InvalidMaxLengthError(text.length, maxLength, this.getName()); + } + this.acroField.setMaxLength(maxLength); + } + }; + PDFTextField2.prototype.removeMaxLength = function() { + this.markAsDirty(); + this.acroField.removeMaxLength(); + }; + PDFTextField2.prototype.setImage = function(image) { + var fieldAlignment = this.getAlignment(); + var alignment = fieldAlignment === TextAlignment.Center ? ImageAlignment.Center : fieldAlignment === TextAlignment.Right ? ImageAlignment.Right : ImageAlignment.Left; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var streamRef = this.createImageAppearanceStream(widget, image, alignment); + this.updateWidgetAppearances(widget, { normal: streamRef }); + } + this.markAsClean(); + }; + PDFTextField2.prototype.setFontSize = function(fontSize) { + assertPositive(fontSize, "fontSize"); + this.acroField.setFontSize(fontSize); + this.markAsDirty(); + }; + PDFTextField2.prototype.isMultiline = function() { + return this.acroField.hasFlag(AcroTextFlags.Multiline); + }; + PDFTextField2.prototype.enableMultiline = function() { + this.markAsDirty(); + this.acroField.setFlagTo(AcroTextFlags.Multiline, true); + }; + PDFTextField2.prototype.disableMultiline = function() { + this.markAsDirty(); + this.acroField.setFlagTo(AcroTextFlags.Multiline, false); + }; + PDFTextField2.prototype.isPassword = function() { + return this.acroField.hasFlag(AcroTextFlags.Password); + }; + PDFTextField2.prototype.enablePassword = function() { + this.acroField.setFlagTo(AcroTextFlags.Password, true); + }; + PDFTextField2.prototype.disablePassword = function() { + this.acroField.setFlagTo(AcroTextFlags.Password, false); + }; + PDFTextField2.prototype.isFileSelector = function() { + return this.acroField.hasFlag(AcroTextFlags.FileSelect); + }; + PDFTextField2.prototype.enableFileSelection = function() { + this.acroField.setFlagTo(AcroTextFlags.FileSelect, true); + }; + PDFTextField2.prototype.disableFileSelection = function() { + this.acroField.setFlagTo(AcroTextFlags.FileSelect, false); + }; + PDFTextField2.prototype.isSpellChecked = function() { + return !this.acroField.hasFlag(AcroTextFlags.DoNotSpellCheck); + }; + PDFTextField2.prototype.enableSpellChecking = function() { + this.acroField.setFlagTo(AcroTextFlags.DoNotSpellCheck, false); + }; + PDFTextField2.prototype.disableSpellChecking = function() { + this.acroField.setFlagTo(AcroTextFlags.DoNotSpellCheck, true); + }; + PDFTextField2.prototype.isScrollable = function() { + return !this.acroField.hasFlag(AcroTextFlags.DoNotScroll); + }; + PDFTextField2.prototype.enableScrolling = function() { + this.acroField.setFlagTo(AcroTextFlags.DoNotScroll, false); + }; + PDFTextField2.prototype.disableScrolling = function() { + this.acroField.setFlagTo(AcroTextFlags.DoNotScroll, true); + }; + PDFTextField2.prototype.isCombed = function() { + return this.acroField.hasFlag(AcroTextFlags.Comb) && !this.isMultiline() && !this.isPassword() && !this.isFileSelector() && this.getMaxLength() !== void 0; + }; + PDFTextField2.prototype.enableCombing = function() { + if (this.getMaxLength() === void 0) { + var msg = "PDFTextFields must have a max length in order to be combed"; + console.warn(msg); + } + this.markAsDirty(); + this.disableMultiline(); + this.disablePassword(); + this.disableFileSelection(); + this.acroField.setFlagTo(AcroTextFlags.Comb, true); + }; + PDFTextField2.prototype.disableCombing = function() { + this.markAsDirty(); + this.acroField.setFlagTo(AcroTextFlags.Comb, false); + }; + PDFTextField2.prototype.isRichFormatted = function() { + return this.acroField.hasFlag(AcroTextFlags.RichText); + }; + PDFTextField2.prototype.enableRichFormatting = function() { + this.acroField.setFlagTo(AcroTextFlags.RichText, true); + }; + PDFTextField2.prototype.disableRichFormatting = function() { + this.acroField.setFlagTo(AcroTextFlags.RichText, false); + }; + PDFTextField2.prototype.addToPage = function(page, options) { + var _a, _b, _c, _d, _e, _f, _g; + assertIs(page, "page", [[PDFPage_default, "PDFPage"]]); + assertFieldAppearanceOptions(options); + if (!options) + options = {}; + if (!("textColor" in options)) + options.textColor = rgb(0, 0, 0); + if (!("backgroundColor" in options)) + options.backgroundColor = rgb(1, 1, 1); + if (!("borderColor" in options)) + options.borderColor = rgb(0, 0, 0); + if (!("borderWidth" in options)) + options.borderWidth = 1; + var widget = this.createWidget({ + x: (_a = options.x) !== null && _a !== void 0 ? _a : 0, + y: (_b = options.y) !== null && _b !== void 0 ? _b : 0, + width: (_c = options.width) !== null && _c !== void 0 ? _c : 200, + height: (_d = options.height) !== null && _d !== void 0 ? _d : 50, + textColor: options.textColor, + backgroundColor: options.backgroundColor, + borderColor: options.borderColor, + borderWidth: (_e = options.borderWidth) !== null && _e !== void 0 ? _e : 0, + rotate: (_f = options.rotate) !== null && _f !== void 0 ? _f : degrees(0), + hidden: options.hidden, + page: page.ref + }); + var widgetRef = this.doc.context.register(widget.dict); + this.acroField.addWidget(widgetRef); + var font = (_g = options.font) !== null && _g !== void 0 ? _g : this.doc.getForm().getDefaultFont(); + this.updateWidgetAppearance(widget, font); + page.node.addAnnot(widgetRef); + }; + PDFTextField2.prototype.needsAppearancesUpdate = function() { + var _a; + if (this.isDirty()) + return true; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var hasAppearances = ((_a = widget.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal) instanceof PDFStream_default; + if (!hasAppearances) + return true; + } + return false; + }; + PDFTextField2.prototype.defaultUpdateAppearances = function(font) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + this.updateAppearances(font); + }; + PDFTextField2.prototype.updateAppearances = function(font, provider) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + assertOrUndefined(provider, "provider", [Function]); + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + this.updateWidgetAppearance(widget, font, provider); + } + this.markAsClean(); + }; + PDFTextField2.prototype.updateWidgetAppearance = function(widget, font, provider) { + var apProvider = provider !== null && provider !== void 0 ? provider : defaultTextFieldAppearanceProvider; + var appearances = normalizeAppearance(apProvider(this, widget, font)); + this.updateWidgetAppearanceWithFont(widget, font, appearances); + }; + PDFTextField2.of = function(acroText, ref, doc) { + return new PDFTextField2(acroText, ref, doc); + }; + return PDFTextField2; + }(PDFField_default) +); +var PDFTextField_default = PDFTextField; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/StandardFonts.js +var StandardFonts; +(function(StandardFonts2) { + StandardFonts2["Courier"] = "Courier"; + StandardFonts2["CourierBold"] = "Courier-Bold"; + StandardFonts2["CourierOblique"] = "Courier-Oblique"; + StandardFonts2["CourierBoldOblique"] = "Courier-BoldOblique"; + StandardFonts2["Helvetica"] = "Helvetica"; + StandardFonts2["HelveticaBold"] = "Helvetica-Bold"; + StandardFonts2["HelveticaOblique"] = "Helvetica-Oblique"; + StandardFonts2["HelveticaBoldOblique"] = "Helvetica-BoldOblique"; + StandardFonts2["TimesRoman"] = "Times-Roman"; + StandardFonts2["TimesRomanBold"] = "Times-Bold"; + StandardFonts2["TimesRomanItalic"] = "Times-Italic"; + StandardFonts2["TimesRomanBoldItalic"] = "Times-BoldItalic"; + StandardFonts2["Symbol"] = "Symbol"; + StandardFonts2["ZapfDingbats"] = "ZapfDingbats"; +})(StandardFonts || (StandardFonts = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFForm.js +var PDFForm = ( + /** @class */ + function() { + function PDFForm2(acroForm, doc) { + var _this = this; + this.embedDefaultFont = function() { + return _this.doc.embedStandardFont(StandardFonts.Helvetica); + }; + assertIs(acroForm, "acroForm", [[PDFAcroForm_default, "PDFAcroForm"]]); + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + this.acroForm = acroForm; + this.doc = doc; + this.dirtyFields = /* @__PURE__ */ new Set(); + this.defaultFontCache = Cache_default.populatedBy(this.embedDefaultFont); + } + PDFForm2.prototype.hasXFA = function() { + return this.acroForm.dict.has(PDFName_default.of("XFA")); + }; + PDFForm2.prototype.deleteXFA = function() { + this.acroForm.dict.delete(PDFName_default.of("XFA")); + }; + PDFForm2.prototype.getFields = function() { + var allFields = this.acroForm.getAllFields(); + var fields = []; + for (var idx = 0, len = allFields.length; idx < len; idx++) { + var _a = allFields[idx], acroField = _a[0], ref = _a[1]; + var field = convertToPDFField(acroField, ref, this.doc); + if (field) + fields.push(field); + } + return fields; + }; + PDFForm2.prototype.getFieldMaybe = function(name) { + assertIs(name, "name", ["string"]); + var fields = this.getFields(); + for (var idx = 0, len = fields.length; idx < len; idx++) { + var field = fields[idx]; + if (field.getName() === name) + return field; + } + return void 0; + }; + PDFForm2.prototype.getField = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getFieldMaybe(name); + if (field) + return field; + throw new NoSuchFieldError(name); + }; + PDFForm2.prototype.getButton = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFButton_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFButton_default, field); + }; + PDFForm2.prototype.getCheckBox = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFCheckBox_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFCheckBox_default, field); + }; + PDFForm2.prototype.getDropdown = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFDropdown_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFDropdown_default, field); + }; + PDFForm2.prototype.getOptionList = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFOptionList_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFOptionList_default, field); + }; + PDFForm2.prototype.getRadioGroup = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFRadioGroup_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFRadioGroup_default, field); + }; + PDFForm2.prototype.getSignature = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFSignature_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFSignature_default, field); + }; + PDFForm2.prototype.getTextField = function(name) { + assertIs(name, "name", ["string"]); + var field = this.getField(name); + if (field instanceof PDFTextField_default) + return field; + throw new UnexpectedFieldTypeError(name, PDFTextField_default, field); + }; + PDFForm2.prototype.createButton = function(name) { + assertIs(name, "name", ["string"]); + var nameParts = splitFieldName(name); + var parent = this.findOrCreateNonTerminals(nameParts.nonTerminal); + var button = PDFAcroPushButton_default.create(this.doc.context); + button.setPartialName(nameParts.terminal); + addFieldToParent(parent, [button, button.ref], nameParts.terminal); + return PDFButton_default.of(button, button.ref, this.doc); + }; + PDFForm2.prototype.createCheckBox = function(name) { + assertIs(name, "name", ["string"]); + var nameParts = splitFieldName(name); + var parent = this.findOrCreateNonTerminals(nameParts.nonTerminal); + var checkBox = PDFAcroCheckBox_default.create(this.doc.context); + checkBox.setPartialName(nameParts.terminal); + addFieldToParent(parent, [checkBox, checkBox.ref], nameParts.terminal); + return PDFCheckBox_default.of(checkBox, checkBox.ref, this.doc); + }; + PDFForm2.prototype.createDropdown = function(name) { + assertIs(name, "name", ["string"]); + var nameParts = splitFieldName(name); + var parent = this.findOrCreateNonTerminals(nameParts.nonTerminal); + var comboBox = PDFAcroComboBox_default.create(this.doc.context); + comboBox.setPartialName(nameParts.terminal); + addFieldToParent(parent, [comboBox, comboBox.ref], nameParts.terminal); + return PDFDropdown_default.of(comboBox, comboBox.ref, this.doc); + }; + PDFForm2.prototype.createOptionList = function(name) { + assertIs(name, "name", ["string"]); + var nameParts = splitFieldName(name); + var parent = this.findOrCreateNonTerminals(nameParts.nonTerminal); + var listBox = PDFAcroListBox_default.create(this.doc.context); + listBox.setPartialName(nameParts.terminal); + addFieldToParent(parent, [listBox, listBox.ref], nameParts.terminal); + return PDFOptionList_default.of(listBox, listBox.ref, this.doc); + }; + PDFForm2.prototype.createRadioGroup = function(name) { + assertIs(name, "name", ["string"]); + var nameParts = splitFieldName(name); + var parent = this.findOrCreateNonTerminals(nameParts.nonTerminal); + var radioButton = PDFAcroRadioButton_default.create(this.doc.context); + radioButton.setPartialName(nameParts.terminal); + addFieldToParent(parent, [radioButton, radioButton.ref], nameParts.terminal); + return PDFRadioGroup_default.of(radioButton, radioButton.ref, this.doc); + }; + PDFForm2.prototype.createTextField = function(name) { + assertIs(name, "name", ["string"]); + var nameParts = splitFieldName(name); + var parent = this.findOrCreateNonTerminals(nameParts.nonTerminal); + var text = PDFAcroText_default.create(this.doc.context); + text.setPartialName(nameParts.terminal); + addFieldToParent(parent, [text, text.ref], nameParts.terminal); + return PDFTextField_default.of(text, text.ref, this.doc); + }; + PDFForm2.prototype.flatten = function(options) { + if (options === void 0) { + options = { updateFieldAppearances: true }; + } + if (options.updateFieldAppearances) { + this.updateFieldAppearances(); + } + var fields = this.getFields(); + for (var i = 0, lenFields = fields.length; i < lenFields; i++) { + var field = fields[i]; + var widgets = field.acroField.getWidgets(); + for (var j = 0, lenWidgets = widgets.length; j < lenWidgets; j++) { + var widget = widgets[j]; + var page = this.findWidgetPage(widget); + var widgetRef = this.findWidgetAppearanceRef(field, widget); + var xObjectKey = page.node.newXObject("FlatWidget", widgetRef); + var rectangle = widget.getRectangle(); + var operators = __spreadArrays([ + pushGraphicsState(), + translate(rectangle.x, rectangle.y) + ], rotateInPlace(__assign(__assign({}, rectangle), { rotation: 0 })), [ + drawObject(xObjectKey), + popGraphicsState() + ]).filter(Boolean); + page.pushOperators.apply(page, operators); + } + this.removeField(field); + } + }; + PDFForm2.prototype.removeField = function(field) { + var widgets = field.acroField.getWidgets(); + var pages = /* @__PURE__ */ new Set(); + for (var i = 0, len = widgets.length; i < len; i++) { + var widget = widgets[i]; + var widgetRef = this.findWidgetAppearanceRef(field, widget); + var page = this.findWidgetPage(widget); + pages.add(page); + page.node.removeAnnot(widgetRef); + } + pages.forEach(function(page2) { + return page2.node.removeAnnot(field.ref); + }); + this.acroForm.removeField(field.acroField); + var fieldKids = field.acroField.normalizedEntries().Kids; + var kidsCount = fieldKids.size(); + for (var childIndex = 0; childIndex < kidsCount; childIndex++) { + var child = fieldKids.get(childIndex); + if (child instanceof PDFRef_default) { + this.doc.context.delete(child); + } + } + this.doc.context.delete(field.ref); + }; + PDFForm2.prototype.updateFieldAppearances = function(font) { + assertOrUndefined(font, "font", [[PDFFont_default, "PDFFont"]]); + font = font !== null && font !== void 0 ? font : this.getDefaultFont(); + var fields = this.getFields(); + for (var idx = 0, len = fields.length; idx < len; idx++) { + var field = fields[idx]; + if (field.needsAppearancesUpdate()) { + field.defaultUpdateAppearances(font); + } + } + }; + PDFForm2.prototype.markFieldAsDirty = function(fieldRef) { + assertOrUndefined(fieldRef, "fieldRef", [[PDFRef_default, "PDFRef"]]); + this.dirtyFields.add(fieldRef); + }; + PDFForm2.prototype.markFieldAsClean = function(fieldRef) { + assertOrUndefined(fieldRef, "fieldRef", [[PDFRef_default, "PDFRef"]]); + this.dirtyFields.delete(fieldRef); + }; + PDFForm2.prototype.fieldIsDirty = function(fieldRef) { + assertOrUndefined(fieldRef, "fieldRef", [[PDFRef_default, "PDFRef"]]); + return this.dirtyFields.has(fieldRef); + }; + PDFForm2.prototype.getDefaultFont = function() { + return this.defaultFontCache.access(); + }; + PDFForm2.prototype.findWidgetPage = function(widget) { + var pageRef = widget.P(); + var page = this.doc.getPages().find(function(x) { + return x.ref === pageRef; + }); + if (page === void 0) { + var widgetRef = this.doc.context.getObjectRef(widget.dict); + if (widgetRef === void 0) { + throw new Error("Could not find PDFRef for PDFObject"); + } + page = this.doc.findPageForAnnotationRef(widgetRef); + if (page === void 0) { + throw new Error("Could not find page for PDFRef " + widgetRef); + } + } + return page; + }; + PDFForm2.prototype.findWidgetAppearanceRef = function(field, widget) { + var _a; + var refOrDict = widget.getNormalAppearance(); + if (refOrDict instanceof PDFDict_default && (field instanceof PDFCheckBox_default || field instanceof PDFRadioGroup_default)) { + var value = field.acroField.getValue(); + var ref = (_a = refOrDict.get(value)) !== null && _a !== void 0 ? _a : refOrDict.get(PDFName_default.of("Off")); + if (ref instanceof PDFRef_default) { + refOrDict = ref; + } + } + if (!(refOrDict instanceof PDFRef_default)) { + var name_1 = field.getName(); + throw new Error("Failed to extract appearance ref for: " + name_1); + } + return refOrDict; + }; + PDFForm2.prototype.findOrCreateNonTerminals = function(partialNames) { + var nonTerminal = [ + this.acroForm + ]; + for (var idx = 0, len = partialNames.length; idx < len; idx++) { + var namePart = partialNames[idx]; + if (!namePart) + throw new InvalidFieldNamePartError(namePart); + var parent_1 = nonTerminal[0], parentRef = nonTerminal[1]; + var res = this.findNonTerminal(namePart, parent_1); + if (res) { + nonTerminal = res; + } else { + var node = PDFAcroNonTerminal_default.create(this.doc.context); + node.setPartialName(namePart); + node.setParent(parentRef); + var nodeRef = this.doc.context.register(node.dict); + parent_1.addField(nodeRef); + nonTerminal = [node, nodeRef]; + } + } + return nonTerminal; + }; + PDFForm2.prototype.findNonTerminal = function(partialName, parent) { + var fields = parent instanceof PDFAcroForm_default ? this.acroForm.getFields() : createPDFAcroFields(parent.Kids()); + for (var idx = 0, len = fields.length; idx < len; idx++) { + var _a = fields[idx], field = _a[0], ref = _a[1]; + if (field.getPartialName() === partialName) { + if (field instanceof PDFAcroNonTerminal_default) + return [field, ref]; + throw new FieldAlreadyExistsError(partialName); + } + } + return void 0; + }; + PDFForm2.of = function(acroForm, doc) { + return new PDFForm2(acroForm, doc); + }; + return PDFForm2; + }() +); +var PDFForm_default = PDFForm; +var convertToPDFField = function(field, ref, doc) { + if (field instanceof PDFAcroPushButton_default) + return PDFButton_default.of(field, ref, doc); + if (field instanceof PDFAcroCheckBox_default) + return PDFCheckBox_default.of(field, ref, doc); + if (field instanceof PDFAcroComboBox_default) + return PDFDropdown_default.of(field, ref, doc); + if (field instanceof PDFAcroListBox_default) + return PDFOptionList_default.of(field, ref, doc); + if (field instanceof PDFAcroText_default) + return PDFTextField_default.of(field, ref, doc); + if (field instanceof PDFAcroRadioButton_default) { + return PDFRadioGroup_default.of(field, ref, doc); + } + if (field instanceof PDFAcroSignature_default) { + return PDFSignature_default.of(field, ref, doc); + } + return void 0; +}; +var splitFieldName = function(fullyQualifiedName) { + if (fullyQualifiedName.length === 0) { + throw new Error("PDF field names must not be empty strings"); + } + var parts = fullyQualifiedName.split("."); + for (var idx = 0, len = parts.length; idx < len; idx++) { + if (parts[idx] === "") { + throw new Error('Periods in PDF field names must be separated by at least one character: "' + fullyQualifiedName + '"'); + } + } + if (parts.length === 1) + return { nonTerminal: [], terminal: parts[0] }; + return { + nonTerminal: parts.slice(0, parts.length - 1), + terminal: parts[parts.length - 1] + }; +}; +var addFieldToParent = function(_a, _b, partialName) { + var parent = _a[0], parentRef = _a[1]; + var field = _b[0], fieldRef = _b[1]; + var entries = parent.normalizedEntries(); + var fields = createPDFAcroFields("Kids" in entries ? entries.Kids : entries.Fields); + for (var idx = 0, len = fields.length; idx < len; idx++) { + if (fields[idx][0].getPartialName() === partialName) { + throw new FieldAlreadyExistsError(partialName); + } + } + parent.addField(fieldRef); + field.setParent(parentRef); +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/sizes.js +var PageSizes = { + "4A0": [4767.87, 6740.79], + "2A0": [3370.39, 4767.87], + A0: [2383.94, 3370.39], + A1: [1683.78, 2383.94], + A2: [1190.55, 1683.78], + A3: [841.89, 1190.55], + A4: [595.28, 841.89], + A5: [419.53, 595.28], + A6: [297.64, 419.53], + A7: [209.76, 297.64], + A8: [147.4, 209.76], + A9: [104.88, 147.4], + A10: [73.7, 104.88], + B0: [2834.65, 4008.19], + B1: [2004.09, 2834.65], + B2: [1417.32, 2004.09], + B3: [1000.63, 1417.32], + B4: [708.66, 1000.63], + B5: [498.9, 708.66], + B6: [354.33, 498.9], + B7: [249.45, 354.33], + B8: [175.75, 249.45], + B9: [124.72, 175.75], + B10: [87.87, 124.72], + C0: [2599.37, 3676.54], + C1: [1836.85, 2599.37], + C2: [1298.27, 1836.85], + C3: [918.43, 1298.27], + C4: [649.13, 918.43], + C5: [459.21, 649.13], + C6: [323.15, 459.21], + C7: [229.61, 323.15], + C8: [161.57, 229.61], + C9: [113.39, 161.57], + C10: [79.37, 113.39], + RA0: [2437.8, 3458.27], + RA1: [1729.13, 2437.8], + RA2: [1218.9, 1729.13], + RA3: [864.57, 1218.9], + RA4: [609.45, 864.57], + SRA0: [2551.18, 3628.35], + SRA1: [1814.17, 2551.18], + SRA2: [1275.59, 1814.17], + SRA3: [907.09, 1275.59], + SRA4: [637.8, 907.09], + Executive: [521.86, 756], + Folio: [612, 936], + Legal: [612, 1008], + Letter: [612, 792], + Tabloid: [792, 1224] +}; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFDocumentOptions.js +var ParseSpeeds; +(function(ParseSpeeds2) { + ParseSpeeds2[ParseSpeeds2["Fastest"] = Infinity] = "Fastest"; + ParseSpeeds2[ParseSpeeds2["Fast"] = 1500] = "Fast"; + ParseSpeeds2[ParseSpeeds2["Medium"] = 500] = "Medium"; + ParseSpeeds2[ParseSpeeds2["Slow"] = 100] = "Slow"; +})(ParseSpeeds || (ParseSpeeds = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFEmbeddedFile.js +var PDFEmbeddedFile = ( + /** @class */ + function() { + function PDFEmbeddedFile2(ref, doc, embedder) { + this.alreadyEmbedded = false; + this.ref = ref; + this.doc = doc; + this.embedder = embedder; + } + PDFEmbeddedFile2.prototype.embed = function() { + return __awaiter(this, void 0, void 0, function() { + var ref, Names, EmbeddedFiles, EFNames, AF; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + if (!!this.alreadyEmbedded) return [3, 2]; + return [4, this.embedder.embedIntoContext(this.doc.context, this.ref)]; + case 1: + ref = _a.sent(); + if (!this.doc.catalog.has(PDFName_default.of("Names"))) { + this.doc.catalog.set(PDFName_default.of("Names"), this.doc.context.obj({})); + } + Names = this.doc.catalog.lookup(PDFName_default.of("Names"), PDFDict_default); + if (!Names.has(PDFName_default.of("EmbeddedFiles"))) { + Names.set(PDFName_default.of("EmbeddedFiles"), this.doc.context.obj({})); + } + EmbeddedFiles = Names.lookup(PDFName_default.of("EmbeddedFiles"), PDFDict_default); + if (!EmbeddedFiles.has(PDFName_default.of("Names"))) { + EmbeddedFiles.set(PDFName_default.of("Names"), this.doc.context.obj([])); + } + EFNames = EmbeddedFiles.lookup(PDFName_default.of("Names"), PDFArray_default); + EFNames.push(PDFHexString_default.fromText(this.embedder.fileName)); + EFNames.push(ref); + if (!this.doc.catalog.has(PDFName_default.of("AF"))) { + this.doc.catalog.set(PDFName_default.of("AF"), this.doc.context.obj([])); + } + AF = this.doc.catalog.lookup(PDFName_default.of("AF"), PDFArray_default); + AF.push(ref); + this.alreadyEmbedded = true; + _a.label = 2; + case 2: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFEmbeddedFile2.of = function(ref, doc, embedder) { + return new PDFEmbeddedFile2(ref, doc, embedder); + }; + return PDFEmbeddedFile2; + }() +); +var PDFEmbeddedFile_default = PDFEmbeddedFile; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFJavaScript.js +var PDFJavaScript = ( + /** @class */ + function() { + function PDFJavaScript2(ref, doc, embedder) { + this.alreadyEmbedded = false; + this.ref = ref; + this.doc = doc; + this.embedder = embedder; + } + PDFJavaScript2.prototype.embed = function() { + return __awaiter(this, void 0, void 0, function() { + var _a, catalog, context, ref, Names, Javascript, JSNames; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + if (!!this.alreadyEmbedded) return [3, 2]; + _a = this.doc, catalog = _a.catalog, context = _a.context; + return [4, this.embedder.embedIntoContext(this.doc.context, this.ref)]; + case 1: + ref = _b.sent(); + if (!catalog.has(PDFName_default.of("Names"))) { + catalog.set(PDFName_default.of("Names"), context.obj({})); + } + Names = catalog.lookup(PDFName_default.of("Names"), PDFDict_default); + if (!Names.has(PDFName_default.of("JavaScript"))) { + Names.set(PDFName_default.of("JavaScript"), context.obj({})); + } + Javascript = Names.lookup(PDFName_default.of("JavaScript"), PDFDict_default); + if (!Javascript.has(PDFName_default.of("Names"))) { + Javascript.set(PDFName_default.of("Names"), context.obj([])); + } + JSNames = Javascript.lookup(PDFName_default.of("Names"), PDFArray_default); + JSNames.push(PDFHexString_default.fromText(this.embedder.scriptName)); + JSNames.push(ref); + this.alreadyEmbedded = true; + _b.label = 2; + case 2: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFJavaScript2.of = function(ref, doc, embedder) { + return new PDFJavaScript2(ref, doc, embedder); + }; + return PDFJavaScript2; + }() +); +var PDFJavaScript_default = PDFJavaScript; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/core/embedders/JavaScriptEmbedder.js +var JavaScriptEmbedder = ( + /** @class */ + function() { + function JavaScriptEmbedder2(script, scriptName) { + this.script = script; + this.scriptName = scriptName; + } + JavaScriptEmbedder2.for = function(script, scriptName) { + return new JavaScriptEmbedder2(script, scriptName); + }; + JavaScriptEmbedder2.prototype.embedIntoContext = function(context, ref) { + return __awaiter(this, void 0, void 0, function() { + var jsActionDict; + return __generator(this, function(_a) { + jsActionDict = context.obj({ + Type: "Action", + S: "JavaScript", + JS: PDFHexString_default.fromText(this.script) + }); + if (ref) { + context.assign(ref, jsActionDict); + return [2, ref]; + } else { + return [2, context.register(jsActionDict)]; + } + return [ + 2 + /*return*/ + ]; + }); + }); + }; + return JavaScriptEmbedder2; + }() +); +var JavaScriptEmbedder_default = JavaScriptEmbedder; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFDocument.js +var PDFDocument = ( + /** @class */ + function() { + function PDFDocument2(context, ignoreEncryption, updateMetadata) { + var _this = this; + this.defaultWordBreaks = [" "]; + this.computePages = function() { + var pages = []; + _this.catalog.Pages().traverse(function(node, ref) { + if (node instanceof PDFPageLeaf_default) { + var page = _this.pageMap.get(node); + if (!page) { + page = PDFPage_default.of(node, ref, _this); + _this.pageMap.set(node, page); + } + pages.push(page); + } + }); + return pages; + }; + this.getOrCreateForm = function() { + var acroForm = _this.catalog.getOrCreateAcroForm(); + return PDFForm_default.of(acroForm, _this); + }; + assertIs(context, "context", [[PDFContext_default, "PDFContext"]]); + assertIs(ignoreEncryption, "ignoreEncryption", ["boolean"]); + this.context = context; + this.catalog = context.lookup(context.trailerInfo.Root); + this.isEncrypted = !!context.lookup(context.trailerInfo.Encrypt); + this.pageCache = Cache_default.populatedBy(this.computePages); + this.pageMap = /* @__PURE__ */ new Map(); + this.formCache = Cache_default.populatedBy(this.getOrCreateForm); + this.fonts = []; + this.images = []; + this.embeddedPages = []; + this.embeddedFiles = []; + this.javaScripts = []; + if (!ignoreEncryption && this.isEncrypted) + throw new EncryptedPDFError(); + if (updateMetadata) + this.updateInfoDict(); + } + PDFDocument2.load = function(pdf, options) { + if (options === void 0) { + options = {}; + } + return __awaiter(this, void 0, void 0, function() { + var _a, ignoreEncryption, _b, parseSpeed, _c, throwOnInvalidObject, _d, updateMetadata, _e, capNumbers, bytes, context; + return __generator(this, function(_f) { + switch (_f.label) { + case 0: + _a = options.ignoreEncryption, ignoreEncryption = _a === void 0 ? false : _a, _b = options.parseSpeed, parseSpeed = _b === void 0 ? ParseSpeeds.Slow : _b, _c = options.throwOnInvalidObject, throwOnInvalidObject = _c === void 0 ? false : _c, _d = options.updateMetadata, updateMetadata = _d === void 0 ? true : _d, _e = options.capNumbers, capNumbers = _e === void 0 ? false : _e; + assertIs(pdf, "pdf", ["string", Uint8Array, ArrayBuffer]); + assertIs(ignoreEncryption, "ignoreEncryption", ["boolean"]); + assertIs(parseSpeed, "parseSpeed", ["number"]); + assertIs(throwOnInvalidObject, "throwOnInvalidObject", ["boolean"]); + bytes = toUint8Array(pdf); + return [4, PDFParser_default.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers).parseDocument()]; + case 1: + context = _f.sent(); + return [2, new PDFDocument2(context, ignoreEncryption, updateMetadata)]; + } + }); + }); + }; + PDFDocument2.create = function(options) { + if (options === void 0) { + options = {}; + } + return __awaiter(this, void 0, void 0, function() { + var _a, updateMetadata, context, pageTree, pageTreeRef, catalog; + return __generator(this, function(_b) { + _a = options.updateMetadata, updateMetadata = _a === void 0 ? true : _a; + context = PDFContext_default.create(); + pageTree = PDFPageTree_default.withContext(context); + pageTreeRef = context.register(pageTree); + catalog = PDFCatalog_default.withContextAndPages(context, pageTreeRef); + context.trailerInfo.Root = context.register(catalog); + return [2, new PDFDocument2(context, false, updateMetadata)]; + }); + }); + }; + PDFDocument2.prototype.registerFontkit = function(fontkit) { + this.fontkit = fontkit; + }; + PDFDocument2.prototype.getForm = function() { + var form = this.formCache.access(); + if (form.hasXFA()) { + console.warn("Removing XFA form data as pdf-lib does not support reading or writing XFA"); + form.deleteXFA(); + } + return form; + }; + PDFDocument2.prototype.getTitle = function() { + var title = this.getInfoDict().lookup(PDFName_default.Title); + if (!title) + return void 0; + assertIsLiteralOrHexString(title); + return title.decodeText(); + }; + PDFDocument2.prototype.getAuthor = function() { + var author = this.getInfoDict().lookup(PDFName_default.Author); + if (!author) + return void 0; + assertIsLiteralOrHexString(author); + return author.decodeText(); + }; + PDFDocument2.prototype.getSubject = function() { + var subject = this.getInfoDict().lookup(PDFName_default.Subject); + if (!subject) + return void 0; + assertIsLiteralOrHexString(subject); + return subject.decodeText(); + }; + PDFDocument2.prototype.getKeywords = function() { + var keywords = this.getInfoDict().lookup(PDFName_default.Keywords); + if (!keywords) + return void 0; + assertIsLiteralOrHexString(keywords); + return keywords.decodeText(); + }; + PDFDocument2.prototype.getCreator = function() { + var creator = this.getInfoDict().lookup(PDFName_default.Creator); + if (!creator) + return void 0; + assertIsLiteralOrHexString(creator); + return creator.decodeText(); + }; + PDFDocument2.prototype.getProducer = function() { + var producer = this.getInfoDict().lookup(PDFName_default.Producer); + if (!producer) + return void 0; + assertIsLiteralOrHexString(producer); + return producer.decodeText(); + }; + PDFDocument2.prototype.getCreationDate = function() { + var creationDate = this.getInfoDict().lookup(PDFName_default.CreationDate); + if (!creationDate) + return void 0; + assertIsLiteralOrHexString(creationDate); + return creationDate.decodeDate(); + }; + PDFDocument2.prototype.getModificationDate = function() { + var modificationDate = this.getInfoDict().lookup(PDFName_default.ModDate); + if (!modificationDate) + return void 0; + assertIsLiteralOrHexString(modificationDate); + return modificationDate.decodeDate(); + }; + PDFDocument2.prototype.setTitle = function(title, options) { + assertIs(title, "title", ["string"]); + var key = PDFName_default.of("Title"); + this.getInfoDict().set(key, PDFHexString_default.fromText(title)); + if (options === null || options === void 0 ? void 0 : options.showInWindowTitleBar) { + var prefs = this.catalog.getOrCreateViewerPreferences(); + prefs.setDisplayDocTitle(true); + } + }; + PDFDocument2.prototype.setAuthor = function(author) { + assertIs(author, "author", ["string"]); + var key = PDFName_default.of("Author"); + this.getInfoDict().set(key, PDFHexString_default.fromText(author)); + }; + PDFDocument2.prototype.setSubject = function(subject) { + assertIs(subject, "author", ["string"]); + var key = PDFName_default.of("Subject"); + this.getInfoDict().set(key, PDFHexString_default.fromText(subject)); + }; + PDFDocument2.prototype.setKeywords = function(keywords) { + assertIs(keywords, "keywords", [Array]); + var key = PDFName_default.of("Keywords"); + this.getInfoDict().set(key, PDFHexString_default.fromText(keywords.join(" "))); + }; + PDFDocument2.prototype.setCreator = function(creator) { + assertIs(creator, "creator", ["string"]); + var key = PDFName_default.of("Creator"); + this.getInfoDict().set(key, PDFHexString_default.fromText(creator)); + }; + PDFDocument2.prototype.setProducer = function(producer) { + assertIs(producer, "creator", ["string"]); + var key = PDFName_default.of("Producer"); + this.getInfoDict().set(key, PDFHexString_default.fromText(producer)); + }; + PDFDocument2.prototype.setLanguage = function(language) { + assertIs(language, "language", ["string"]); + var key = PDFName_default.of("Lang"); + this.catalog.set(key, PDFString_default.of(language)); + }; + PDFDocument2.prototype.setCreationDate = function(creationDate) { + assertIs(creationDate, "creationDate", [[Date, "Date"]]); + var key = PDFName_default.of("CreationDate"); + this.getInfoDict().set(key, PDFString_default.fromDate(creationDate)); + }; + PDFDocument2.prototype.setModificationDate = function(modificationDate) { + assertIs(modificationDate, "modificationDate", [[Date, "Date"]]); + var key = PDFName_default.of("ModDate"); + this.getInfoDict().set(key, PDFString_default.fromDate(modificationDate)); + }; + PDFDocument2.prototype.getPageCount = function() { + if (this.pageCount === void 0) + this.pageCount = this.getPages().length; + return this.pageCount; + }; + PDFDocument2.prototype.getPages = function() { + return this.pageCache.access(); + }; + PDFDocument2.prototype.getPage = function(index) { + var pages = this.getPages(); + assertRange(index, "index", 0, pages.length - 1); + return pages[index]; + }; + PDFDocument2.prototype.getPageIndices = function() { + return range(0, this.getPageCount()); + }; + PDFDocument2.prototype.removePage = function(index) { + var pageCount = this.getPageCount(); + if (this.pageCount === 0) + throw new RemovePageFromEmptyDocumentError(); + assertRange(index, "index", 0, pageCount - 1); + this.catalog.removeLeafNode(index); + this.pageCount = pageCount - 1; + }; + PDFDocument2.prototype.addPage = function(page) { + assertIs(page, "page", ["undefined", [PDFPage_default, "PDFPage"], Array]); + return this.insertPage(this.getPageCount(), page); + }; + PDFDocument2.prototype.insertPage = function(index, page) { + var pageCount = this.getPageCount(); + assertRange(index, "index", 0, pageCount); + assertIs(page, "page", ["undefined", [PDFPage_default, "PDFPage"], Array]); + if (!page || Array.isArray(page)) { + var dims = Array.isArray(page) ? page : PageSizes.A4; + page = PDFPage_default.create(this); + page.setSize.apply(page, dims); + } else if (page.doc !== this) { + throw new ForeignPageError(); + } + var parentRef = this.catalog.insertLeafNode(page.ref, index); + page.node.setParent(parentRef); + this.pageMap.set(page.node, page); + this.pageCache.invalidate(); + this.pageCount = pageCount + 1; + return page; + }; + PDFDocument2.prototype.copyPages = function(srcDoc, indices) { + return __awaiter(this, void 0, void 0, function() { + var copier, srcPages, copiedPages, idx, len, srcPage, copiedPage, ref; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + assertIs(srcDoc, "srcDoc", [[PDFDocument2, "PDFDocument"]]); + assertIs(indices, "indices", [Array]); + return [4, srcDoc.flush()]; + case 1: + _a.sent(); + copier = PDFObjectCopier_default.for(srcDoc.context, this.context); + srcPages = srcDoc.getPages(); + copiedPages = new Array(indices.length); + for (idx = 0, len = indices.length; idx < len; idx++) { + srcPage = srcPages[indices[idx]]; + copiedPage = copier.copy(srcPage.node); + ref = this.context.register(copiedPage); + copiedPages[idx] = PDFPage_default.of(copiedPage, ref, this); + } + return [2, copiedPages]; + } + }); + }); + }; + PDFDocument2.prototype.copy = function() { + return __awaiter(this, void 0, void 0, function() { + var pdfCopy, contentPages, idx, len; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, PDFDocument2.create()]; + case 1: + pdfCopy = _a.sent(); + return [4, pdfCopy.copyPages(this, this.getPageIndices())]; + case 2: + contentPages = _a.sent(); + for (idx = 0, len = contentPages.length; idx < len; idx++) { + pdfCopy.addPage(contentPages[idx]); + } + if (this.getAuthor() !== void 0) { + pdfCopy.setAuthor(this.getAuthor()); + } + if (this.getCreationDate() !== void 0) { + pdfCopy.setCreationDate(this.getCreationDate()); + } + if (this.getCreator() !== void 0) { + pdfCopy.setCreator(this.getCreator()); + } + if (this.getModificationDate() !== void 0) { + pdfCopy.setModificationDate(this.getModificationDate()); + } + if (this.getProducer() !== void 0) { + pdfCopy.setProducer(this.getProducer()); + } + if (this.getSubject() !== void 0) { + pdfCopy.setSubject(this.getSubject()); + } + if (this.getTitle() !== void 0) { + pdfCopy.setTitle(this.getTitle()); + } + pdfCopy.defaultWordBreaks = this.defaultWordBreaks; + return [2, pdfCopy]; + } + }); + }); + }; + PDFDocument2.prototype.addJavaScript = function(name, script) { + assertIs(name, "name", ["string"]); + assertIs(script, "script", ["string"]); + var embedder = JavaScriptEmbedder_default.for(script, name); + var ref = this.context.nextRef(); + var javaScript = PDFJavaScript_default.of(ref, this, embedder); + this.javaScripts.push(javaScript); + }; + PDFDocument2.prototype.attach = function(attachment, name, options) { + if (options === void 0) { + options = {}; + } + return __awaiter(this, void 0, void 0, function() { + var bytes, embedder, ref, embeddedFile; + return __generator(this, function(_a) { + assertIs(attachment, "attachment", ["string", Uint8Array, ArrayBuffer]); + assertIs(name, "name", ["string"]); + assertOrUndefined(options.mimeType, "mimeType", ["string"]); + assertOrUndefined(options.description, "description", ["string"]); + assertOrUndefined(options.creationDate, "options.creationDate", [Date]); + assertOrUndefined(options.modificationDate, "options.modificationDate", [ + Date + ]); + assertIsOneOfOrUndefined(options.afRelationship, "options.afRelationship", AFRelationship); + bytes = toUint8Array(attachment); + embedder = FileEmbedder_default.for(bytes, name, options); + ref = this.context.nextRef(); + embeddedFile = PDFEmbeddedFile_default.of(ref, this, embedder); + this.embeddedFiles.push(embeddedFile); + return [ + 2 + /*return*/ + ]; + }); + }); + }; + PDFDocument2.prototype.embedFont = function(font, options) { + if (options === void 0) { + options = {}; + } + return __awaiter(this, void 0, void 0, function() { + var _a, subset, customName, features, embedder, bytes, fontkit, _b, ref, pdfFont; + return __generator(this, function(_c) { + switch (_c.label) { + case 0: + _a = options.subset, subset = _a === void 0 ? false : _a, customName = options.customName, features = options.features; + assertIs(font, "font", ["string", Uint8Array, ArrayBuffer]); + assertIs(subset, "subset", ["boolean"]); + if (!isStandardFont(font)) return [3, 1]; + embedder = StandardFontEmbedder_default.for(font, customName); + return [3, 7]; + case 1: + if (!canBeConvertedToUint8Array(font)) return [3, 6]; + bytes = toUint8Array(font); + fontkit = this.assertFontkit(); + if (!subset) return [3, 3]; + return [4, CustomFontSubsetEmbedder_default.for(fontkit, bytes, customName, features)]; + case 2: + _b = _c.sent(); + return [3, 5]; + case 3: + return [4, CustomFontEmbedder_default.for(fontkit, bytes, customName, features)]; + case 4: + _b = _c.sent(); + _c.label = 5; + case 5: + embedder = _b; + return [3, 7]; + case 6: + throw new TypeError("`font` must be one of `StandardFonts | string | Uint8Array | ArrayBuffer`"); + case 7: + ref = this.context.nextRef(); + pdfFont = PDFFont_default.of(ref, this, embedder); + this.fonts.push(pdfFont); + return [2, pdfFont]; + } + }); + }); + }; + PDFDocument2.prototype.embedStandardFont = function(font, customName) { + assertIs(font, "font", ["string"]); + if (!isStandardFont(font)) { + throw new TypeError("`font` must be one of type `StandardFonts`"); + } + var embedder = StandardFontEmbedder_default.for(font, customName); + var ref = this.context.nextRef(); + var pdfFont = PDFFont_default.of(ref, this, embedder); + this.fonts.push(pdfFont); + return pdfFont; + }; + PDFDocument2.prototype.embedJpg = function(jpg) { + return __awaiter(this, void 0, void 0, function() { + var bytes, embedder, ref, pdfImage; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + assertIs(jpg, "jpg", ["string", Uint8Array, ArrayBuffer]); + bytes = toUint8Array(jpg); + return [4, JpegEmbedder_default.for(bytes)]; + case 1: + embedder = _a.sent(); + ref = this.context.nextRef(); + pdfImage = PDFImage_default.of(ref, this, embedder); + this.images.push(pdfImage); + return [2, pdfImage]; + } + }); + }); + }; + PDFDocument2.prototype.embedPng = function(png) { + return __awaiter(this, void 0, void 0, function() { + var bytes, embedder, ref, pdfImage; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + assertIs(png, "png", ["string", Uint8Array, ArrayBuffer]); + bytes = toUint8Array(png); + return [4, PngEmbedder_default.for(bytes)]; + case 1: + embedder = _a.sent(); + ref = this.context.nextRef(); + pdfImage = PDFImage_default.of(ref, this, embedder); + this.images.push(pdfImage); + return [2, pdfImage]; + } + }); + }); + }; + PDFDocument2.prototype.embedPdf = function(pdf, indices) { + if (indices === void 0) { + indices = [0]; + } + return __awaiter(this, void 0, void 0, function() { + var srcDoc, _a, srcPages; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + assertIs(pdf, "pdf", [ + "string", + Uint8Array, + ArrayBuffer, + [PDFDocument2, "PDFDocument"] + ]); + assertIs(indices, "indices", [Array]); + if (!(pdf instanceof PDFDocument2)) return [3, 1]; + _a = pdf; + return [3, 3]; + case 1: + return [4, PDFDocument2.load(pdf)]; + case 2: + _a = _b.sent(); + _b.label = 3; + case 3: + srcDoc = _a; + srcPages = pluckIndices(srcDoc.getPages(), indices); + return [2, this.embedPages(srcPages)]; + } + }); + }); + }; + PDFDocument2.prototype.embedPage = function(page, boundingBox, transformationMatrix) { + return __awaiter(this, void 0, void 0, function() { + var embeddedPage; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + assertIs(page, "page", [[PDFPage_default, "PDFPage"]]); + return [4, this.embedPages([page], [boundingBox], [transformationMatrix])]; + case 1: + embeddedPage = _a.sent()[0]; + return [2, embeddedPage]; + } + }); + }); + }; + PDFDocument2.prototype.embedPages = function(pages, boundingBoxes, transformationMatrices) { + if (boundingBoxes === void 0) { + boundingBoxes = []; + } + if (transformationMatrices === void 0) { + transformationMatrices = []; + } + return __awaiter(this, void 0, void 0, function() { + var idx, len, currPage, nextPage, context, maybeCopyPage, embeddedPages, idx, len, page, box, matrix, embedder, ref; + var _a; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + if (pages.length === 0) + return [2, []]; + for (idx = 0, len = pages.length - 1; idx < len; idx++) { + currPage = pages[idx]; + nextPage = pages[idx + 1]; + if (currPage.node.context !== nextPage.node.context) { + throw new PageEmbeddingMismatchedContextError(); + } + } + context = pages[0].node.context; + maybeCopyPage = context === this.context ? function(p) { + return p; + } : PDFObjectCopier_default.for(context, this.context).copy; + embeddedPages = new Array(pages.length); + idx = 0, len = pages.length; + _b.label = 1; + case 1: + if (!(idx < len)) return [3, 4]; + page = maybeCopyPage(pages[idx].node); + box = boundingBoxes[idx]; + matrix = transformationMatrices[idx]; + return [4, PDFPageEmbedder_default.for(page, box, matrix)]; + case 2: + embedder = _b.sent(); + ref = this.context.nextRef(); + embeddedPages[idx] = PDFEmbeddedPage_default.of(ref, this, embedder); + _b.label = 3; + case 3: + idx++; + return [3, 1]; + case 4: + (_a = this.embeddedPages).push.apply(_a, embeddedPages); + return [2, embeddedPages]; + } + }); + }); + }; + PDFDocument2.prototype.flush = function() { + return __awaiter(this, void 0, void 0, function() { + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + return [4, this.embedAll(this.fonts)]; + case 1: + _a.sent(); + return [4, this.embedAll(this.images)]; + case 2: + _a.sent(); + return [4, this.embedAll(this.embeddedPages)]; + case 3: + _a.sent(); + return [4, this.embedAll(this.embeddedFiles)]; + case 4: + _a.sent(); + return [4, this.embedAll(this.javaScripts)]; + case 5: + _a.sent(); + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFDocument2.prototype.save = function(options) { + if (options === void 0) { + options = {}; + } + return __awaiter(this, void 0, void 0, function() { + var _a, useObjectStreams, _b, addDefaultPage, _c, objectsPerTick, _d, updateFieldAppearances, form, Writer; + return __generator(this, function(_e) { + switch (_e.label) { + case 0: + _a = options.useObjectStreams, useObjectStreams = _a === void 0 ? true : _a, _b = options.addDefaultPage, addDefaultPage = _b === void 0 ? true : _b, _c = options.objectsPerTick, objectsPerTick = _c === void 0 ? 50 : _c, _d = options.updateFieldAppearances, updateFieldAppearances = _d === void 0 ? true : _d; + assertIs(useObjectStreams, "useObjectStreams", ["boolean"]); + assertIs(addDefaultPage, "addDefaultPage", ["boolean"]); + assertIs(objectsPerTick, "objectsPerTick", ["number"]); + assertIs(updateFieldAppearances, "updateFieldAppearances", ["boolean"]); + if (addDefaultPage && this.getPageCount() === 0) + this.addPage(); + if (updateFieldAppearances) { + form = this.formCache.getValue(); + if (form) + form.updateFieldAppearances(); + } + return [4, this.flush()]; + case 1: + _e.sent(); + Writer = useObjectStreams ? PDFStreamWriter_default : PDFWriter_default; + return [2, Writer.forContext(this.context, objectsPerTick).serializeToBuffer()]; + } + }); + }); + }; + PDFDocument2.prototype.saveAsBase64 = function(options) { + if (options === void 0) { + options = {}; + } + return __awaiter(this, void 0, void 0, function() { + var _a, dataUri, otherOptions, bytes, base64; + return __generator(this, function(_b) { + switch (_b.label) { + case 0: + _a = options.dataUri, dataUri = _a === void 0 ? false : _a, otherOptions = __rest(options, ["dataUri"]); + assertIs(dataUri, "dataUri", ["boolean"]); + return [4, this.save(otherOptions)]; + case 1: + bytes = _b.sent(); + base64 = encodeToBase64(bytes); + return [2, dataUri ? "data:application/pdf;base64," + base64 : base64]; + } + }); + }); + }; + PDFDocument2.prototype.findPageForAnnotationRef = function(ref) { + var pages = this.getPages(); + for (var idx = 0, len = pages.length; idx < len; idx++) { + var page = pages[idx]; + var annotations = page.node.Annots(); + if ((annotations === null || annotations === void 0 ? void 0 : annotations.indexOf(ref)) !== void 0) { + return page; + } + } + return void 0; + }; + PDFDocument2.prototype.embedAll = function(embeddables) { + return __awaiter(this, void 0, void 0, function() { + var idx, len; + return __generator(this, function(_a) { + switch (_a.label) { + case 0: + idx = 0, len = embeddables.length; + _a.label = 1; + case 1: + if (!(idx < len)) return [3, 4]; + return [4, embeddables[idx].embed()]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + idx++; + return [3, 1]; + case 4: + return [ + 2 + /*return*/ + ]; + } + }); + }); + }; + PDFDocument2.prototype.updateInfoDict = function() { + var pdfLib = "pdf-lib (https://github.com/Hopding/pdf-lib)"; + var now = /* @__PURE__ */ new Date(); + var info = this.getInfoDict(); + this.setProducer(pdfLib); + this.setModificationDate(now); + if (!info.get(PDFName_default.of("Creator"))) + this.setCreator(pdfLib); + if (!info.get(PDFName_default.of("CreationDate"))) + this.setCreationDate(now); + }; + PDFDocument2.prototype.getInfoDict = function() { + var existingInfo = this.context.lookup(this.context.trailerInfo.Info); + if (existingInfo instanceof PDFDict_default) + return existingInfo; + var newInfo = this.context.obj({}); + this.context.trailerInfo.Info = this.context.register(newInfo); + return newInfo; + }; + PDFDocument2.prototype.assertFontkit = function() { + if (!this.fontkit) + throw new FontkitNotRegisteredError(); + return this.fontkit; + }; + return PDFDocument2; + }() +); +var PDFDocument_default = PDFDocument; +function assertIsLiteralOrHexString(pdfObject) { + if (!(pdfObject instanceof PDFHexString_default) && !(pdfObject instanceof PDFString_default)) { + throw new UnexpectedObjectTypeError([PDFHexString_default, PDFString_default], pdfObject); + } +} + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFPageOptions.js +var BlendMode; +(function(BlendMode2) { + BlendMode2["Normal"] = "Normal"; + BlendMode2["Multiply"] = "Multiply"; + BlendMode2["Screen"] = "Screen"; + BlendMode2["Overlay"] = "Overlay"; + BlendMode2["Darken"] = "Darken"; + BlendMode2["Lighten"] = "Lighten"; + BlendMode2["ColorDodge"] = "ColorDodge"; + BlendMode2["ColorBurn"] = "ColorBurn"; + BlendMode2["HardLight"] = "HardLight"; + BlendMode2["SoftLight"] = "SoftLight"; + BlendMode2["Difference"] = "Difference"; + BlendMode2["Exclusion"] = "Exclusion"; +})(BlendMode || (BlendMode = {})); + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/PDFPage.js +var PDFPage = ( + /** @class */ + function() { + function PDFPage2(leafNode, ref, doc) { + this.fontSize = 24; + this.fontColor = rgb(0, 0, 0); + this.lineHeight = 24; + this.x = 0; + this.y = 0; + assertIs(leafNode, "leafNode", [[PDFPageLeaf_default, "PDFPageLeaf"]]); + assertIs(ref, "ref", [[PDFRef_default, "PDFRef"]]); + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + this.node = leafNode; + this.ref = ref; + this.doc = doc; + } + PDFPage2.prototype.setRotation = function(angle) { + var degreesAngle = toDegrees(angle); + assertMultiple(degreesAngle, "degreesAngle", 90); + this.node.set(PDFName_default.of("Rotate"), this.doc.context.obj(degreesAngle)); + }; + PDFPage2.prototype.getRotation = function() { + var Rotate = this.node.Rotate(); + return degrees(Rotate ? Rotate.asNumber() : 0); + }; + PDFPage2.prototype.setSize = function(width, height) { + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var mediaBox = this.getMediaBox(); + this.setMediaBox(mediaBox.x, mediaBox.y, width, height); + var cropBox = this.getCropBox(); + var bleedBox = this.getBleedBox(); + var trimBox = this.getTrimBox(); + var artBox = this.getArtBox(); + var hasCropBox = this.node.CropBox(); + var hasBleedBox = this.node.BleedBox(); + var hasTrimBox = this.node.TrimBox(); + var hasArtBox = this.node.ArtBox(); + if (hasCropBox && rectanglesAreEqual(cropBox, mediaBox)) { + this.setCropBox(mediaBox.x, mediaBox.y, width, height); + } + if (hasBleedBox && rectanglesAreEqual(bleedBox, mediaBox)) { + this.setBleedBox(mediaBox.x, mediaBox.y, width, height); + } + if (hasTrimBox && rectanglesAreEqual(trimBox, mediaBox)) { + this.setTrimBox(mediaBox.x, mediaBox.y, width, height); + } + if (hasArtBox && rectanglesAreEqual(artBox, mediaBox)) { + this.setArtBox(mediaBox.x, mediaBox.y, width, height); + } + }; + PDFPage2.prototype.setWidth = function(width) { + assertIs(width, "width", ["number"]); + this.setSize(width, this.getSize().height); + }; + PDFPage2.prototype.setHeight = function(height) { + assertIs(height, "height", ["number"]); + this.setSize(this.getSize().width, height); + }; + PDFPage2.prototype.setMediaBox = function(x, y, width, height) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var mediaBox = this.doc.context.obj([x, y, x + width, y + height]); + this.node.set(PDFName_default.MediaBox, mediaBox); + }; + PDFPage2.prototype.setCropBox = function(x, y, width, height) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var cropBox = this.doc.context.obj([x, y, x + width, y + height]); + this.node.set(PDFName_default.CropBox, cropBox); + }; + PDFPage2.prototype.setBleedBox = function(x, y, width, height) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var bleedBox = this.doc.context.obj([x, y, x + width, y + height]); + this.node.set(PDFName_default.BleedBox, bleedBox); + }; + PDFPage2.prototype.setTrimBox = function(x, y, width, height) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var trimBox = this.doc.context.obj([x, y, x + width, y + height]); + this.node.set(PDFName_default.TrimBox, trimBox); + }; + PDFPage2.prototype.setArtBox = function(x, y, width, height) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + assertIs(width, "width", ["number"]); + assertIs(height, "height", ["number"]); + var artBox = this.doc.context.obj([x, y, x + width, y + height]); + this.node.set(PDFName_default.ArtBox, artBox); + }; + PDFPage2.prototype.getSize = function() { + var _a = this.getMediaBox(), width = _a.width, height = _a.height; + return { width, height }; + }; + PDFPage2.prototype.getWidth = function() { + return this.getSize().width; + }; + PDFPage2.prototype.getHeight = function() { + return this.getSize().height; + }; + PDFPage2.prototype.getMediaBox = function() { + var mediaBox = this.node.MediaBox(); + return mediaBox.asRectangle(); + }; + PDFPage2.prototype.getCropBox = function() { + var _a; + var cropBox = this.node.CropBox(); + return (_a = cropBox === null || cropBox === void 0 ? void 0 : cropBox.asRectangle()) !== null && _a !== void 0 ? _a : this.getMediaBox(); + }; + PDFPage2.prototype.getBleedBox = function() { + var _a; + var bleedBox = this.node.BleedBox(); + return (_a = bleedBox === null || bleedBox === void 0 ? void 0 : bleedBox.asRectangle()) !== null && _a !== void 0 ? _a : this.getCropBox(); + }; + PDFPage2.prototype.getTrimBox = function() { + var _a; + var trimBox = this.node.TrimBox(); + return (_a = trimBox === null || trimBox === void 0 ? void 0 : trimBox.asRectangle()) !== null && _a !== void 0 ? _a : this.getCropBox(); + }; + PDFPage2.prototype.getArtBox = function() { + var _a; + var artBox = this.node.ArtBox(); + return (_a = artBox === null || artBox === void 0 ? void 0 : artBox.asRectangle()) !== null && _a !== void 0 ? _a : this.getCropBox(); + }; + PDFPage2.prototype.translateContent = function(x, y) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + this.node.normalize(); + this.getContentStream(); + var start = this.createContentStream(pushGraphicsState(), translate(x, y)); + var startRef = this.doc.context.register(start); + var end = this.createContentStream(popGraphicsState()); + var endRef = this.doc.context.register(end); + this.node.wrapContentStreams(startRef, endRef); + }; + PDFPage2.prototype.scale = function(x, y) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + this.setSize(this.getWidth() * x, this.getHeight() * y); + this.scaleContent(x, y); + this.scaleAnnotations(x, y); + }; + PDFPage2.prototype.scaleContent = function(x, y) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + this.node.normalize(); + this.getContentStream(); + var start = this.createContentStream(pushGraphicsState(), scale(x, y)); + var startRef = this.doc.context.register(start); + var end = this.createContentStream(popGraphicsState()); + var endRef = this.doc.context.register(end); + this.node.wrapContentStreams(startRef, endRef); + }; + PDFPage2.prototype.scaleAnnotations = function(x, y) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + var annots = this.node.Annots(); + if (!annots) + return; + for (var idx = 0; idx < annots.size(); idx++) { + var annot = annots.lookup(idx); + if (annot instanceof PDFDict_default) + this.scaleAnnot(annot, x, y); + } + }; + PDFPage2.prototype.resetPosition = function() { + this.getContentStream(false); + this.x = 0; + this.y = 0; + }; + PDFPage2.prototype.setFont = function(font) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + this.font = font; + this.fontKey = this.node.newFontDictionary(this.font.name, this.font.ref); + }; + PDFPage2.prototype.setFontSize = function(fontSize) { + assertIs(fontSize, "fontSize", ["number"]); + this.fontSize = fontSize; + }; + PDFPage2.prototype.setFontColor = function(fontColor) { + assertIs(fontColor, "fontColor", [[Object, "Color"]]); + this.fontColor = fontColor; + }; + PDFPage2.prototype.setLineHeight = function(lineHeight) { + assertIs(lineHeight, "lineHeight", ["number"]); + this.lineHeight = lineHeight; + }; + PDFPage2.prototype.getPosition = function() { + return { x: this.x, y: this.y }; + }; + PDFPage2.prototype.getX = function() { + return this.x; + }; + PDFPage2.prototype.getY = function() { + return this.y; + }; + PDFPage2.prototype.moveTo = function(x, y) { + assertIs(x, "x", ["number"]); + assertIs(y, "y", ["number"]); + this.x = x; + this.y = y; + }; + PDFPage2.prototype.moveDown = function(yDecrease) { + assertIs(yDecrease, "yDecrease", ["number"]); + this.y -= yDecrease; + }; + PDFPage2.prototype.moveUp = function(yIncrease) { + assertIs(yIncrease, "yIncrease", ["number"]); + this.y += yIncrease; + }; + PDFPage2.prototype.moveLeft = function(xDecrease) { + assertIs(xDecrease, "xDecrease", ["number"]); + this.x -= xDecrease; + }; + PDFPage2.prototype.moveRight = function(xIncrease) { + assertIs(xIncrease, "xIncrease", ["number"]); + this.x += xIncrease; + }; + PDFPage2.prototype.pushOperators = function() { + var operator = []; + for (var _i = 0; _i < arguments.length; _i++) { + operator[_i] = arguments[_i]; + } + assertEachIs(operator, "operator", [[PDFOperator_default, "PDFOperator"]]); + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, operator); + }; + PDFPage2.prototype.drawText = function(text, options) { + var _a, _b, _c, _d, _e, _f, _g; + if (options === void 0) { + options = {}; + } + assertIs(text, "text", ["string"]); + assertOrUndefined(options.color, "options.color", [[Object, "Color"]]); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertOrUndefined(options.font, "options.font", [[PDFFont_default, "PDFFont"]]); + assertOrUndefined(options.size, "options.size", ["number"]); + assertOrUndefined(options.rotate, "options.rotate", [[Object, "Rotation"]]); + assertOrUndefined(options.xSkew, "options.xSkew", [[Object, "Rotation"]]); + assertOrUndefined(options.ySkew, "options.ySkew", [[Object, "Rotation"]]); + assertOrUndefined(options.x, "options.x", ["number"]); + assertOrUndefined(options.y, "options.y", ["number"]); + assertOrUndefined(options.lineHeight, "options.lineHeight", ["number"]); + assertOrUndefined(options.maxWidth, "options.maxWidth", ["number"]); + assertOrUndefined(options.wordBreaks, "options.wordBreaks", [Array]); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var _h = this.setOrEmbedFont(options.font), oldFont = _h.oldFont, newFont = _h.newFont, newFontKey = _h.newFontKey; + var fontSize = options.size || this.fontSize; + var wordBreaks = options.wordBreaks || this.doc.defaultWordBreaks; + var textWidth = function(t) { + return newFont.widthOfTextAtSize(t, fontSize); + }; + var lines = options.maxWidth === void 0 ? lineSplit(cleanText(text)) : breakTextIntoLines(text, wordBreaks, options.maxWidth, textWidth); + var encodedLines = new Array(lines.length); + for (var idx = 0, len = lines.length; idx < len; idx++) { + encodedLines[idx] = newFont.encodeText(lines[idx]); + } + var graphicsStateKey = this.maybeEmbedGraphicsState({ + opacity: options.opacity, + blendMode: options.blendMode + }); + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawLinesOfText(encodedLines, { + color: (_a = options.color) !== null && _a !== void 0 ? _a : this.fontColor, + font: newFontKey, + size: fontSize, + rotate: (_b = options.rotate) !== null && _b !== void 0 ? _b : degrees(0), + xSkew: (_c = options.xSkew) !== null && _c !== void 0 ? _c : degrees(0), + ySkew: (_d = options.ySkew) !== null && _d !== void 0 ? _d : degrees(0), + x: (_e = options.x) !== null && _e !== void 0 ? _e : this.x, + y: (_f = options.y) !== null && _f !== void 0 ? _f : this.y, + lineHeight: (_g = options.lineHeight) !== null && _g !== void 0 ? _g : this.lineHeight, + graphicsState: graphicsStateKey + })); + if (options.font) { + if (oldFont) + this.setFont(oldFont); + else + this.resetFont(); + } + }; + PDFPage2.prototype.drawImage = function(image, options) { + var _a, _b, _c, _d, _e, _f, _g; + if (options === void 0) { + options = {}; + } + assertIs(image, "image", [[PDFImage_default, "PDFImage"]]); + assertOrUndefined(options.x, "options.x", ["number"]); + assertOrUndefined(options.y, "options.y", ["number"]); + assertOrUndefined(options.width, "options.width", ["number"]); + assertOrUndefined(options.height, "options.height", ["number"]); + assertOrUndefined(options.rotate, "options.rotate", [[Object, "Rotation"]]); + assertOrUndefined(options.xSkew, "options.xSkew", [[Object, "Rotation"]]); + assertOrUndefined(options.ySkew, "options.ySkew", [[Object, "Rotation"]]); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var xObjectKey = this.node.newXObject("Image", image.ref); + var graphicsStateKey = this.maybeEmbedGraphicsState({ + opacity: options.opacity, + blendMode: options.blendMode + }); + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawImage(xObjectKey, { + x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x, + y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y, + width: (_c = options.width) !== null && _c !== void 0 ? _c : image.size().width, + height: (_d = options.height) !== null && _d !== void 0 ? _d : image.size().height, + rotate: (_e = options.rotate) !== null && _e !== void 0 ? _e : degrees(0), + xSkew: (_f = options.xSkew) !== null && _f !== void 0 ? _f : degrees(0), + ySkew: (_g = options.ySkew) !== null && _g !== void 0 ? _g : degrees(0), + graphicsState: graphicsStateKey + })); + }; + PDFPage2.prototype.drawPage = function(embeddedPage, options) { + var _a, _b, _c, _d, _e; + if (options === void 0) { + options = {}; + } + assertIs(embeddedPage, "embeddedPage", [ + [PDFEmbeddedPage_default, "PDFEmbeddedPage"] + ]); + assertOrUndefined(options.x, "options.x", ["number"]); + assertOrUndefined(options.y, "options.y", ["number"]); + assertOrUndefined(options.xScale, "options.xScale", ["number"]); + assertOrUndefined(options.yScale, "options.yScale", ["number"]); + assertOrUndefined(options.width, "options.width", ["number"]); + assertOrUndefined(options.height, "options.height", ["number"]); + assertOrUndefined(options.rotate, "options.rotate", [[Object, "Rotation"]]); + assertOrUndefined(options.xSkew, "options.xSkew", [[Object, "Rotation"]]); + assertOrUndefined(options.ySkew, "options.ySkew", [[Object, "Rotation"]]); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var xObjectKey = this.node.newXObject("EmbeddedPdfPage", embeddedPage.ref); + var graphicsStateKey = this.maybeEmbedGraphicsState({ + opacity: options.opacity, + blendMode: options.blendMode + }); + var xScale = options.width !== void 0 ? options.width / embeddedPage.width : options.xScale !== void 0 ? options.xScale : 1; + var yScale = options.height !== void 0 ? options.height / embeddedPage.height : options.yScale !== void 0 ? options.yScale : 1; + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawPage(xObjectKey, { + x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x, + y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y, + xScale, + yScale, + rotate: (_c = options.rotate) !== null && _c !== void 0 ? _c : degrees(0), + xSkew: (_d = options.xSkew) !== null && _d !== void 0 ? _d : degrees(0), + ySkew: (_e = options.ySkew) !== null && _e !== void 0 ? _e : degrees(0), + graphicsState: graphicsStateKey + })); + }; + PDFPage2.prototype.drawSvgPath = function(path2, options) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j; + if (options === void 0) { + options = {}; + } + assertIs(path2, "path", ["string"]); + assertOrUndefined(options.x, "options.x", ["number"]); + assertOrUndefined(options.y, "options.y", ["number"]); + assertOrUndefined(options.scale, "options.scale", ["number"]); + assertOrUndefined(options.rotate, "options.rotate", [[Object, "Rotation"]]); + assertOrUndefined(options.borderWidth, "options.borderWidth", ["number"]); + assertOrUndefined(options.color, "options.color", [[Object, "Color"]]); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertOrUndefined(options.borderColor, "options.borderColor", [ + [Object, "Color"] + ]); + assertOrUndefined(options.borderDashArray, "options.borderDashArray", [ + Array + ]); + assertOrUndefined(options.borderDashPhase, "options.borderDashPhase", [ + "number" + ]); + assertIsOneOfOrUndefined(options.borderLineCap, "options.borderLineCap", LineCapStyle); + assertRangeOrUndefined(options.borderOpacity, "options.borderOpacity", 0, 1); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var graphicsStateKey = this.maybeEmbedGraphicsState({ + opacity: options.opacity, + borderOpacity: options.borderOpacity, + blendMode: options.blendMode + }); + if (!("color" in options) && !("borderColor" in options)) { + options.borderColor = rgb(0, 0, 0); + } + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawSvgPath(path2, { + x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x, + y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y, + scale: options.scale, + rotate: (_c = options.rotate) !== null && _c !== void 0 ? _c : degrees(0), + color: (_d = options.color) !== null && _d !== void 0 ? _d : void 0, + borderColor: (_e = options.borderColor) !== null && _e !== void 0 ? _e : void 0, + borderWidth: (_f = options.borderWidth) !== null && _f !== void 0 ? _f : 0, + borderDashArray: (_g = options.borderDashArray) !== null && _g !== void 0 ? _g : void 0, + borderDashPhase: (_h = options.borderDashPhase) !== null && _h !== void 0 ? _h : void 0, + borderLineCap: (_j = options.borderLineCap) !== null && _j !== void 0 ? _j : void 0, + graphicsState: graphicsStateKey + })); + }; + PDFPage2.prototype.drawLine = function(options) { + var _a, _b, _c, _d, _e; + assertIs(options.start, "options.start", [ + [Object, "{ x: number, y: number }"] + ]); + assertIs(options.end, "options.end", [ + [Object, "{ x: number, y: number }"] + ]); + assertIs(options.start.x, "options.start.x", ["number"]); + assertIs(options.start.y, "options.start.y", ["number"]); + assertIs(options.end.x, "options.end.x", ["number"]); + assertIs(options.end.y, "options.end.y", ["number"]); + assertOrUndefined(options.thickness, "options.thickness", ["number"]); + assertOrUndefined(options.color, "options.color", [[Object, "Color"]]); + assertOrUndefined(options.dashArray, "options.dashArray", [Array]); + assertOrUndefined(options.dashPhase, "options.dashPhase", ["number"]); + assertIsOneOfOrUndefined(options.lineCap, "options.lineCap", LineCapStyle); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var graphicsStateKey = this.maybeEmbedGraphicsState({ + borderOpacity: options.opacity, + blendMode: options.blendMode + }); + if (!("color" in options)) { + options.color = rgb(0, 0, 0); + } + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawLine({ + start: options.start, + end: options.end, + thickness: (_a = options.thickness) !== null && _a !== void 0 ? _a : 1, + color: (_b = options.color) !== null && _b !== void 0 ? _b : void 0, + dashArray: (_c = options.dashArray) !== null && _c !== void 0 ? _c : void 0, + dashPhase: (_d = options.dashPhase) !== null && _d !== void 0 ? _d : void 0, + lineCap: (_e = options.lineCap) !== null && _e !== void 0 ? _e : void 0, + graphicsState: graphicsStateKey + })); + }; + PDFPage2.prototype.drawRectangle = function(options) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o; + if (options === void 0) { + options = {}; + } + assertOrUndefined(options.x, "options.x", ["number"]); + assertOrUndefined(options.y, "options.y", ["number"]); + assertOrUndefined(options.width, "options.width", ["number"]); + assertOrUndefined(options.height, "options.height", ["number"]); + assertOrUndefined(options.rotate, "options.rotate", [[Object, "Rotation"]]); + assertOrUndefined(options.xSkew, "options.xSkew", [[Object, "Rotation"]]); + assertOrUndefined(options.ySkew, "options.ySkew", [[Object, "Rotation"]]); + assertOrUndefined(options.borderWidth, "options.borderWidth", ["number"]); + assertOrUndefined(options.color, "options.color", [[Object, "Color"]]); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertOrUndefined(options.borderColor, "options.borderColor", [ + [Object, "Color"] + ]); + assertOrUndefined(options.borderDashArray, "options.borderDashArray", [ + Array + ]); + assertOrUndefined(options.borderDashPhase, "options.borderDashPhase", [ + "number" + ]); + assertIsOneOfOrUndefined(options.borderLineCap, "options.borderLineCap", LineCapStyle); + assertRangeOrUndefined(options.borderOpacity, "options.borderOpacity", 0, 1); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var graphicsStateKey = this.maybeEmbedGraphicsState({ + opacity: options.opacity, + borderOpacity: options.borderOpacity, + blendMode: options.blendMode + }); + if (!("color" in options) && !("borderColor" in options)) { + options.color = rgb(0, 0, 0); + } + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawRectangle({ + x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x, + y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y, + width: (_c = options.width) !== null && _c !== void 0 ? _c : 150, + height: (_d = options.height) !== null && _d !== void 0 ? _d : 100, + rotate: (_e = options.rotate) !== null && _e !== void 0 ? _e : degrees(0), + xSkew: (_f = options.xSkew) !== null && _f !== void 0 ? _f : degrees(0), + ySkew: (_g = options.ySkew) !== null && _g !== void 0 ? _g : degrees(0), + borderWidth: (_h = options.borderWidth) !== null && _h !== void 0 ? _h : 0, + color: (_j = options.color) !== null && _j !== void 0 ? _j : void 0, + borderColor: (_k = options.borderColor) !== null && _k !== void 0 ? _k : void 0, + borderDashArray: (_l = options.borderDashArray) !== null && _l !== void 0 ? _l : void 0, + borderDashPhase: (_m = options.borderDashPhase) !== null && _m !== void 0 ? _m : void 0, + graphicsState: graphicsStateKey, + borderLineCap: (_o = options.borderLineCap) !== null && _o !== void 0 ? _o : void 0 + })); + }; + PDFPage2.prototype.drawSquare = function(options) { + if (options === void 0) { + options = {}; + } + var size = options.size; + assertOrUndefined(size, "size", ["number"]); + this.drawRectangle(__assign(__assign({}, options), { width: size, height: size })); + }; + PDFPage2.prototype.drawEllipse = function(options) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l; + if (options === void 0) { + options = {}; + } + assertOrUndefined(options.x, "options.x", ["number"]); + assertOrUndefined(options.y, "options.y", ["number"]); + assertOrUndefined(options.xScale, "options.xScale", ["number"]); + assertOrUndefined(options.yScale, "options.yScale", ["number"]); + assertOrUndefined(options.rotate, "options.rotate", [[Object, "Rotation"]]); + assertOrUndefined(options.color, "options.color", [[Object, "Color"]]); + assertRangeOrUndefined(options.opacity, "opacity.opacity", 0, 1); + assertOrUndefined(options.borderColor, "options.borderColor", [ + [Object, "Color"] + ]); + assertRangeOrUndefined(options.borderOpacity, "options.borderOpacity", 0, 1); + assertOrUndefined(options.borderWidth, "options.borderWidth", ["number"]); + assertOrUndefined(options.borderDashArray, "options.borderDashArray", [ + Array + ]); + assertOrUndefined(options.borderDashPhase, "options.borderDashPhase", [ + "number" + ]); + assertIsOneOfOrUndefined(options.borderLineCap, "options.borderLineCap", LineCapStyle); + assertIsOneOfOrUndefined(options.blendMode, "options.blendMode", BlendMode); + var graphicsStateKey = this.maybeEmbedGraphicsState({ + opacity: options.opacity, + borderOpacity: options.borderOpacity, + blendMode: options.blendMode + }); + if (!("color" in options) && !("borderColor" in options)) { + options.color = rgb(0, 0, 0); + } + var contentStream = this.getContentStream(); + contentStream.push.apply(contentStream, drawEllipse({ + x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x, + y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y, + xScale: (_c = options.xScale) !== null && _c !== void 0 ? _c : 100, + yScale: (_d = options.yScale) !== null && _d !== void 0 ? _d : 100, + rotate: (_e = options.rotate) !== null && _e !== void 0 ? _e : void 0, + color: (_f = options.color) !== null && _f !== void 0 ? _f : void 0, + borderColor: (_g = options.borderColor) !== null && _g !== void 0 ? _g : void 0, + borderWidth: (_h = options.borderWidth) !== null && _h !== void 0 ? _h : 0, + borderDashArray: (_j = options.borderDashArray) !== null && _j !== void 0 ? _j : void 0, + borderDashPhase: (_k = options.borderDashPhase) !== null && _k !== void 0 ? _k : void 0, + borderLineCap: (_l = options.borderLineCap) !== null && _l !== void 0 ? _l : void 0, + graphicsState: graphicsStateKey + })); + }; + PDFPage2.prototype.drawCircle = function(options) { + if (options === void 0) { + options = {}; + } + var _a = options.size, size = _a === void 0 ? 100 : _a; + assertOrUndefined(size, "size", ["number"]); + this.drawEllipse(__assign(__assign({}, options), { xScale: size, yScale: size })); + }; + PDFPage2.prototype.setOrEmbedFont = function(font) { + var oldFont = this.font; + var oldFontKey = this.fontKey; + if (font) + this.setFont(font); + else + this.getFont(); + var newFont = this.font; + var newFontKey = this.fontKey; + return { oldFont, oldFontKey, newFont, newFontKey }; + }; + PDFPage2.prototype.getFont = function() { + if (!this.font || !this.fontKey) { + var font = this.doc.embedStandardFont(StandardFonts.Helvetica); + this.setFont(font); + } + return [this.font, this.fontKey]; + }; + PDFPage2.prototype.resetFont = function() { + this.font = void 0; + this.fontKey = void 0; + }; + PDFPage2.prototype.getContentStream = function(useExisting) { + if (useExisting === void 0) { + useExisting = true; + } + if (useExisting && this.contentStream) + return this.contentStream; + this.contentStream = this.createContentStream(); + this.contentStreamRef = this.doc.context.register(this.contentStream); + this.node.addContentStream(this.contentStreamRef); + return this.contentStream; + }; + PDFPage2.prototype.createContentStream = function() { + var operators = []; + for (var _i = 0; _i < arguments.length; _i++) { + operators[_i] = arguments[_i]; + } + var dict = this.doc.context.obj({}); + var contentStream = PDFContentStream_default.of(dict, operators); + return contentStream; + }; + PDFPage2.prototype.maybeEmbedGraphicsState = function(options) { + var opacity = options.opacity, borderOpacity = options.borderOpacity, blendMode = options.blendMode; + if (opacity === void 0 && borderOpacity === void 0 && blendMode === void 0) { + return void 0; + } + var graphicsState = this.doc.context.obj({ + Type: "ExtGState", + ca: opacity, + CA: borderOpacity, + BM: blendMode + }); + var key = this.node.newExtGState("GS", graphicsState); + return key; + }; + PDFPage2.prototype.scaleAnnot = function(annot, x, y) { + var selectors = ["RD", "CL", "Vertices", "QuadPoints", "L", "Rect"]; + for (var idx = 0, len = selectors.length; idx < len; idx++) { + var list = annot.lookup(PDFName_default.of(selectors[idx])); + if (list instanceof PDFArray_default) + list.scalePDFNumbers(x, y); + } + var inkLists = annot.lookup(PDFName_default.of("InkList")); + if (inkLists instanceof PDFArray_default) { + for (var idx = 0, len = inkLists.size(); idx < len; idx++) { + var arr = inkLists.lookup(idx); + if (arr instanceof PDFArray_default) + arr.scalePDFNumbers(x, y); + } + } + }; + PDFPage2.of = function(leafNode, ref, doc) { + return new PDFPage2(leafNode, ref, doc); + }; + PDFPage2.create = function(doc) { + assertIs(doc, "doc", [[PDFDocument_default, "PDFDocument"]]); + var dummyRef = PDFRef_default.of(-1); + var pageLeaf = PDFPageLeaf_default.withContextAndParent(doc.context, dummyRef); + var pageRef = doc.context.register(pageLeaf); + return new PDFPage2(pageLeaf, pageRef, doc); + }; + return PDFPage2; + }() +); +var PDFPage_default = PDFPage; + +// node_modules/.pnpm/pdf-lib@1.17.1/node_modules/pdf-lib/es/api/form/PDFButton.js +var PDFButton = ( + /** @class */ + function(_super) { + __extends(PDFButton2, _super); + function PDFButton2(acroPushButton, ref, doc) { + var _this = _super.call(this, acroPushButton, ref, doc) || this; + assertIs(acroPushButton, "acroButton", [ + [PDFAcroPushButton_default, "PDFAcroPushButton"] + ]); + _this.acroField = acroPushButton; + return _this; + } + PDFButton2.prototype.setImage = function(image, alignment) { + if (alignment === void 0) { + alignment = ImageAlignment.Center; + } + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var streamRef = this.createImageAppearanceStream(widget, image, alignment); + this.updateWidgetAppearances(widget, { normal: streamRef }); + } + this.markAsClean(); + }; + PDFButton2.prototype.setFontSize = function(fontSize) { + assertPositive(fontSize, "fontSize"); + this.acroField.setFontSize(fontSize); + this.markAsDirty(); + }; + PDFButton2.prototype.addToPage = function(text, page, options) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l; + assertOrUndefined(text, "text", ["string"]); + assertOrUndefined(page, "page", [[PDFPage_default, "PDFPage"]]); + assertFieldAppearanceOptions(options); + var widget = this.createWidget({ + x: ((_a = options === null || options === void 0 ? void 0 : options.x) !== null && _a !== void 0 ? _a : 0) - ((_b = options === null || options === void 0 ? void 0 : options.borderWidth) !== null && _b !== void 0 ? _b : 0) / 2, + y: ((_c = options === null || options === void 0 ? void 0 : options.y) !== null && _c !== void 0 ? _c : 0) - ((_d = options === null || options === void 0 ? void 0 : options.borderWidth) !== null && _d !== void 0 ? _d : 0) / 2, + width: (_e = options === null || options === void 0 ? void 0 : options.width) !== null && _e !== void 0 ? _e : 100, + height: (_f = options === null || options === void 0 ? void 0 : options.height) !== null && _f !== void 0 ? _f : 50, + textColor: (_g = options === null || options === void 0 ? void 0 : options.textColor) !== null && _g !== void 0 ? _g : rgb(0, 0, 0), + backgroundColor: (_h = options === null || options === void 0 ? void 0 : options.backgroundColor) !== null && _h !== void 0 ? _h : rgb(0.75, 0.75, 0.75), + borderColor: options === null || options === void 0 ? void 0 : options.borderColor, + borderWidth: (_j = options === null || options === void 0 ? void 0 : options.borderWidth) !== null && _j !== void 0 ? _j : 0, + rotate: (_k = options === null || options === void 0 ? void 0 : options.rotate) !== null && _k !== void 0 ? _k : degrees(0), + caption: text, + hidden: options === null || options === void 0 ? void 0 : options.hidden, + page: page.ref + }); + var widgetRef = this.doc.context.register(widget.dict); + this.acroField.addWidget(widgetRef); + var font = (_l = options === null || options === void 0 ? void 0 : options.font) !== null && _l !== void 0 ? _l : this.doc.getForm().getDefaultFont(); + this.updateWidgetAppearance(widget, font); + page.node.addAnnot(widgetRef); + }; + PDFButton2.prototype.needsAppearancesUpdate = function() { + var _a; + if (this.isDirty()) + return true; + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + var hasAppearances = ((_a = widget.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal) instanceof PDFStream_default; + if (!hasAppearances) + return true; + } + return false; + }; + PDFButton2.prototype.defaultUpdateAppearances = function(font) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + this.updateAppearances(font); + }; + PDFButton2.prototype.updateAppearances = function(font, provider) { + assertIs(font, "font", [[PDFFont_default, "PDFFont"]]); + assertOrUndefined(provider, "provider", [Function]); + var widgets = this.acroField.getWidgets(); + for (var idx = 0, len = widgets.length; idx < len; idx++) { + var widget = widgets[idx]; + this.updateWidgetAppearance(widget, font, provider); + } + }; + PDFButton2.prototype.updateWidgetAppearance = function(widget, font, provider) { + var apProvider = provider !== null && provider !== void 0 ? provider : defaultButtonAppearanceProvider; + var appearances = normalizeAppearance(apProvider(this, widget, font)); + this.updateWidgetAppearanceWithFont(widget, font, appearances); + }; + PDFButton2.of = function(acroPushButton, ref, doc) { + return new PDFButton2(acroPushButton, ref, doc); + }; + return PDFButton2; + }(PDFField_default) +); +var PDFButton_default = PDFButton; + +// src/utils.ts +var import_obsidian = require("obsidian"); +var TreeNode = class { + constructor(key, title, level) { + this.children = []; + this.key = key; + this.title = title; + this.level = level; + this.children = []; + } +}; +function getHeadingTree(doc = document) { + const headings = doc.querySelectorAll("h1, h2, h3, h4, h5, h6"); + const root = new TreeNode("", "Root", 0); + let prev = root; + headings.forEach((heading) => { + var _a; + if (heading.style.display == "none") { + return; + } + const level = parseInt(heading.tagName.slice(1)); + const link = heading.querySelector("a.md-print-anchor"); + const regexMatch = /^af:\/\/(.+)$/.exec((_a = link == null ? void 0 : link.href) != null ? _a : ""); + if (!regexMatch) { + return; + } + const newNode = new TreeNode(regexMatch[1], heading.innerText, level); + while (prev.level >= level) { + prev = prev.parent; + } + prev.children.push(newNode); + newNode.parent = prev; + prev = newNode; + }); + return root; +} +function modifyDest(doc) { + const data = /* @__PURE__ */ new Map(); + doc.querySelectorAll("h1, h2, h3, h4, h5, h6").forEach((heading, i) => { + const link = document.createElement("a"); + const flag3 = `${heading.tagName.toLowerCase()}-${i}`; + link.href = `af://${flag3}`; + link.className = "md-print-anchor"; + heading.appendChild(link); + data.set(heading.dataset.heading, flag3); + }); + return data; +} +function convertMapKeysToLowercase(map) { + return new Map(Array.from(map).map(([key, value]) => [key == null ? void 0 : key.toLowerCase(), value])); +} +function fixAnchors(doc, dest, basename) { + const lowerDest = convertMapKeysToLowercase(dest); + doc.querySelectorAll("a.internal-link").forEach((el, i) => { + var _a, _b, _c; + const [title, anchor] = (_b = (_a = el.dataset.href) == null ? void 0 : _a.split("#")) != null ? _b : []; + if (anchor == null ? void 0 : anchor.startsWith("^")) { + el.href = (_c = el.dataset.href) == null ? void 0 : _c.toLowerCase(); + } + if ((anchor == null ? void 0 : anchor.length) > 0) { + if ((title == null ? void 0 : title.length) > 0 && title != basename) { + return; + } + const flag3 = dest.get(anchor) || lowerDest.get(anchor == null ? void 0 : anchor.toLowerCase()); + if (flag3 && !anchor.startsWith("^")) { + el.href = `an://${flag3}`; + } + } + }); +} +var px2mm = (px2) => { + return Math.round(px2 * 0.26458333333719); +}; +var mm2px = (mm) => { + return Math.round(mm * 3.779527559); +}; +function traverseFolder(path2) { + if (path2 instanceof import_obsidian.TFile) { + if (path2.extension == "md") { + return [path2]; + } else { + return []; + } + } + const arr = []; + for (const item of path2.children) { + arr.push(...traverseFolder(item)); + } + return arr; +} +function copyAttributes(node, attributes) { + Array.from(attributes).forEach((attr) => { + node.setAttribute(attr.name, attr.value); + }); +} + +// src/pdf.ts +async function getDestPosition(pdfDoc) { + const pages = pdfDoc.getPages(); + const links = {}; + pages.forEach((page, pageIndex) => { + var _a, _b; + const annotations = page.node.Annots(); + if (!annotations) { + return; + } + const numAnnotations = (_a = annotations == null ? void 0 : annotations.size()) != null ? _a : 0; + for (let annotIndex = 0; annotIndex < numAnnotations; annotIndex++) { + try { + const annotation = annotations.lookup(annotIndex, PDFDict_default); + const subtype = annotation.get(PDFName_default.of("Subtype")); + if ((subtype == null ? void 0 : subtype.toString()) === "/Link") { + const linkDict = annotation.get(PDFName_default.of("A")); + const uri = linkDict == null ? void 0 : linkDict.get(PDFName_default.of("URI")).toString(); + console.debug("uri", uri); + const regexMatch = /^\(af:\/\/(.+)\)$/.exec(uri || ""); + if (regexMatch) { + const rect = (_b = annotation.get(PDFName_default.of("Rect"))) == null ? void 0 : _b.asRectangle(); + const linkUrl = regexMatch[1]; + const yPos = rect.y; + links[linkUrl] = [pageIndex, yPos]; + } + } + } catch (err) { + console.error(err); + } + } + }); + return links; +} +async function setAnchors(pdfDoc, links) { + const pages = pdfDoc.getPages(); + pages.forEach((page, _) => { + var _a; + const annots = page.node.Annots(); + if (!annots) { + return; + } + const numAnnotations = (_a = annots == null ? void 0 : annots.size()) != null ? _a : 0; + for (let idx = 0; idx < numAnnotations; idx++) { + try { + const linkAnnotRef = annots.get(idx); + const linkAnnot = annots.lookup(idx, PDFDict_default); + const subtype = linkAnnot.get(PDFName_default.of("Subtype")); + if ((subtype == null ? void 0 : subtype.toString()) === "/Link") { + const linkDict = linkAnnot.get(PDFName_default.of("A")); + const uri = linkDict == null ? void 0 : linkDict.get(PDFName_default.of("URI")).toString(); + console.debug("uri", uri); + const regexMatch = /^\(an:\/\/(.+)\)$/.exec(uri || ""); + const key = regexMatch == null ? void 0 : regexMatch[1]; + if (key && (links == null ? void 0 : links[key])) { + const [pageIdx, yPos] = links[key]; + const newAnnot = pdfDoc.context.obj({ + Type: "Annot", + Subtype: "Link", + Rect: linkAnnot.lookup(PDFName_default.of("Rect")), + Border: linkAnnot.lookup(PDFName_default.of("Border")), + C: linkAnnot.lookup(PDFName_default.of("C")), + Dest: [pages[pageIdx].ref, "XYZ", null, yPos, null] + }); + pdfDoc.context.assign(linkAnnotRef, newAnnot); + } + } + } catch (err) { + console.error(err); + } + } + }); + return links; +} +function generateOutlines(root, positions, maxLevel = 6) { + var _a, _b; + const _outline = (node) => { + var _a2, _b2; + if (node.level > maxLevel) { + return; + } + const [pageIdx, pos] = (_a2 = positions == null ? void 0 : positions[node.key]) != null ? _a2 : [0, 0]; + const outline = { + title: node.title, + to: [pageIdx, 0, pos], + open: false, + children: [] + }; + if (((_b2 = node.children) == null ? void 0 : _b2.length) > 0) { + for (const item of node.children) { + const child = _outline(item); + if (child) { + outline.children.push(child); + } + } + } + return outline; + }; + return (_b = (_a = _outline(root)) == null ? void 0 : _a.children) != null ? _b : []; +} +var walk = (outlines, callback) => { + for (const outline of outlines) { + const ret = callback(outline); + if ("children" in outline && ret !== false) walk(outline.children, callback); + } +}; +var flatten = (outlines) => { + const result = []; + walk(outlines, (outline) => void result.push(outline)); + return result; +}; +var getOpeningCount = (outlines) => { + let count = 0; + walk(outlines, (outline) => { + count += 1; + return !("open" in outline && !outline.open); + }); + return count; +}; +var setOutline = async (doc, outlines) => { + const rootRef = doc.context.nextRef(); + const refMap = /* @__PURE__ */ new WeakMap(); + for (const outline of flatten(outlines)) { + refMap.set(outline, doc.context.nextRef()); + } + const pageRefs = (() => { + const refs = []; + doc.catalog.Pages().traverse((kid, ref) => { + var _a; + if (((_a = kid.get(kid.context.obj("Type"))) == null ? void 0 : _a.toString()) === "/Page") { + refs.push(ref); + } + }); + return refs; + })(); + const createOutline = (outlines2, parent) => { + const { length } = outlines2; + for (let i = 0; i < length; i += 1) { + const outline = outlines2[i]; + const outlineRef = refMap.get(outline); + const destOrAction = (() => { + if (typeof outline.to === "number") { + return { Dest: [pageRefs[outline.to], "Fit"] }; + } else if (Array.isArray(outline.to)) { + return { + Dest: [pageRefs[outline.to[0]], "XYZ", outline.to[1], outline.to[2], null] + }; + } + return {}; + })(); + const childrenDict = (() => { + if ("children" in outline && outline.children.length > 0) { + createOutline(outline.children, outlineRef); + return { + First: refMap.get(outline.children[0]), + Last: refMap.get(outline.children[outline.children.length - 1]), + Count: getOpeningCount(outline.children) * (outline.open ? 1 : -1) + }; + } + return {}; + })(); + doc.context.assign( + outlineRef, + doc.context.obj({ + Title: PDFHexString_default.fromText(outline.title), + Parent: parent, + ...i > 0 ? { Prev: refMap.get(outlines2[i - 1]) } : {}, + ...i < length - 1 ? { Next: refMap.get(outlines2[i + 1]) } : {}, + ...childrenDict, + ...destOrAction, + F: (outline.italic ? 1 : 0) | (outline.bold ? 2 : 0) + }) + ); + } + }; + createOutline(outlines, rootRef); + const rootCount = getOpeningCount(outlines); + doc.context.assign( + rootRef, + doc.context.obj({ + Type: "Outlines", + ...rootCount > 0 ? { + First: refMap.get(outlines[0]), + Last: refMap.get(outlines[outlines.length - 1]) + } : {}, + Count: rootCount + }) + ); + doc.catalog.set(doc.context.obj("Outlines"), rootRef); +}; +async function editPDF(data, { headings, maxLevel, frontMatter, displayMetadata }) { + const pdfDoc = await PDFDocument_default.load(data); + const posistions = await getDestPosition(pdfDoc); + setAnchors(pdfDoc, posistions); + const outlines = generateOutlines(headings, posistions, maxLevel); + setOutline(pdfDoc, outlines); + if (displayMetadata) { + setMetadata(pdfDoc, frontMatter != null ? frontMatter : {}); + } + data = await pdfDoc.save(); + return data; +} +function setMetadata(pdfDoc, { title, author, keywords, subject, creator, created_at, updated_at }) { + if (title) { + pdfDoc.setTitle(title, { showInWindowTitleBar: true }); + } + if (author) { + pdfDoc.setAuthor(author); + } + if (keywords) { + pdfDoc.setKeywords(typeof keywords == "string" ? [keywords] : keywords); + } + if (subject) { + pdfDoc.setSubject(subject); + } + pdfDoc.setCreator(creator != null ? creator : "Obsidian"); + pdfDoc.setProducer("Obsidian"); + pdfDoc.setCreationDate(new Date(created_at != null ? created_at : /* @__PURE__ */ new Date())); + pdfDoc.setModificationDate(new Date(updated_at != null ? updated_at : /* @__PURE__ */ new Date())); +} +async function exportToPDF(outputFile, config, w, { doc, frontMatter }) { + var _a, _b, _c, _d, _e, _f, _g, _h, _i; + console.log("output pdf:", outputFile); + let pageSize = config["pageSize"]; + if (config["pageSize"] == "Custom" && config["pageWidth"] && config["pageHeight"]) { + pageSize = { + width: parseFloat((_a = config["pageWidth"]) != null ? _a : "0") / 25.4, + height: parseFloat((_b = config["pageHeight"]) != null ? _b : "0") / 25.4 + }; + } + const printOptions = { + landscape: config == null ? void 0 : config["landscape"], + printBackground: config == null ? void 0 : config["printBackground"], + generateTaggedPDF: config == null ? void 0 : config["generateTaggedPDF"], + pageSize, + scale: config["scale"] / 100, + margins: { + marginType: "default" + }, + displayHeaderFooter: config["displayHeader"] || config["displayFooter"], + headerTemplate: config["displayHeader"] ? (_c = frontMatter == null ? void 0 : frontMatter["headerTemplate"]) != null ? _c : config["headerTemplate"] : "", + footerTemplate: config["displayFooter"] ? (_d = frontMatter == null ? void 0 : frontMatter["footerTemplate"]) != null ? _d : config["footerTemplate"] : "" + }; + if (config.marginType == "0") { + printOptions["margins"] = { + marginType: "custom", + top: 0, + bottom: 0, + left: 0, + right: 0 + }; + } else if (config.marginType == "1") { + printOptions["margins"] = { + marginType: "default" + }; + } else if (config.marginType == "2") { + printOptions["margins"] = { + marginType: "custom", + top: 0.1, + bottom: 0.1, + left: 0.1, + right: 0.1 + }; + } else if (config.marginType == "3") { + printOptions["margins"] = { + marginType: "custom", + top: parseFloat((_e = config["marginTop"]) != null ? _e : "0") / 25.4, + bottom: parseFloat((_f = config["marginBottom"]) != null ? _f : "0") / 25.4, + left: parseFloat((_g = config["marginLeft"]) != null ? _g : "0") / 25.4, + right: parseFloat((_h = config["marginRight"]) != null ? _h : "0") / 25.4 + }; + } + try { + let data = await w.printToPDF(printOptions); + data = await editPDF(data, { + headings: getHeadingTree(doc), + frontMatter, + displayMetadata: config == null ? void 0 : config.displayMetadata, + maxLevel: parseInt((_i = config == null ? void 0 : config.maxLevel) != null ? _i : "6") + }); + await fs.writeFile(outputFile, data); + if (config.open) { + import_electron.default.remote.shell.openPath(outputFile); + } + } catch (error2) { + console.error(error2); + } +} +async function getOutputFile(filename, isTimestamp) { + const result = await import_electron.default.remote.dialog.showSaveDialog({ + title: "Export to PDF", + defaultPath: filename + (isTimestamp ? "-" + Date.now() : "") + ".pdf", + filters: [ + { name: "All Files", extensions: ["*"] }, + { name: "PDF", extensions: ["pdf"] } + ], + properties: ["showOverwriteConfirmation", "createDirectory"] + }); + if (result.canceled) { + return; + } + return result.filePath; +} +async function getOutputPath(filename, isTimestamp) { + const result = await import_electron.default.remote.dialog.showOpenDialog({ + title: "Export to PDF", + defaultPath: filename, + properties: ["openDirectory"] + }); + if (result.canceled) { + return; + } + return result.filePaths[0]; +} + +// src/render.ts +var import_obsidian2 = require("obsidian"); +function getAllStyles() { + const cssTexts = []; + Array.from(document.styleSheets).forEach((sheet) => { + var _a, _b, _c; + const id = (_a = sheet.ownerNode) == null ? void 0 : _a.id; + if (id == null ? void 0 : id.startsWith("svelte-")) { + return; + } + const href = (_b = sheet.ownerNode) == null ? void 0 : _b.href; + const division = `/* ----------${id ? `id:${id}` : href ? `href:${href}` : ""}---------- */`; + cssTexts.push(division); + try { + Array.from((_c = sheet == null ? void 0 : sheet.cssRules) != null ? _c : []).forEach((rule) => { + cssTexts.push(rule.cssText); + }); + } catch (error2) { + console.error(error2); + } + }); + cssTexts.push(...getPatchStyle()); + return cssTexts; +} +var CSS_PATCH = ` +/* ---------- css patch ---------- */ + +body { + overflow: auto !important; +} +@media print { + .print .markdown-preview-view { + height: auto !important; + } + .md-print-anchor, .blockid { + white-space: pre !important; + border-left: none !important; + border-right: none !important; + border-top: none !important; + border-bottom: none !important; + display: inline-block !important; + position: absolute !important; + width: 1px !important; + height: 1px !important; + right: 0 !important; + outline: 0 !important; + background: 0 0 !important; + text-decoration: initial !important; + text-shadow: initial !important; + } +} +@media print { + table { + break-inside: auto; + } + tr { + break-inside: avoid; + break-after: auto; + } +} +`; +function getPatchStyle() { + return [CSS_PATCH, ...getPrintStyle()]; +} +function getPrintStyle() { + const cssTexts = []; + Array.from(document.styleSheets).forEach((sheet) => { + var _a; + try { + const cssRules = (_a = sheet == null ? void 0 : sheet.cssRules) != null ? _a : []; + Array.from(cssRules).forEach((rule) => { + if (rule.constructor.name == "CSSMediaRule") { + if (rule.conditionText === "print") { + const res = rule.cssText.replace(/@media print\s*\{(.+)\}/gms, "$1"); + cssTexts.push(res); + } + } + }); + } catch (error2) { + console.error(error2); + } + }); + return cssTexts; +} +function generateDocId(n) { + return Array.from({ length: n }, () => (16 * Math.random() | 0).toString(16)).join(""); +} +function getFrontMatter(app, file) { + var _a; + const cache = app.metadataCache.getFileCache(file); + return (_a = cache == null ? void 0 : cache.frontmatter) != null ? _a : {}; +} +async function renderMarkdown(app, file, config, extra) { + var _a, _b, _c, _d, _e, _f, _g, _h; + const startTime = (/* @__PURE__ */ new Date()).getTime(); + const ws = app.workspace; + if (((_a = ws.getActiveFile()) == null ? void 0 : _a.path) != file.path) { + const leaf = ws.getLeaf(); + await leaf.openFile(file); + } + const view = ws.getActiveViewOfType(import_obsidian2.MarkdownView); + const data = (_e = (_c = view == null ? void 0 : view.data) != null ? _c : (_b = ws == null ? void 0 : ws.getActiveFileView()) == null ? void 0 : _b.data) != null ? _e : (_d = ws.activeEditor) == null ? void 0 : _d.data; + if (!data) { + new import_obsidian2.Notice("data is empty!"); + } + const frontMatter = getFrontMatter(app, file); + const cssclasses = []; + for (const [key, val] of Object.entries(frontMatter)) { + if (key.toLowerCase() == "cssclass" || key.toLowerCase() == "cssclasses") { + if (Array.isArray(val)) { + cssclasses.push(...val); + } else { + cssclasses.push(val); + } + } + } + const comp = new import_obsidian2.Component(); + comp.load(); + const printEl = document.body.createDiv("print"); + const viewEl = printEl.createDiv({ + cls: "markdown-preview-view markdown-rendered " + cssclasses.join(" ") + }); + app.vault.cachedRead(file); + viewEl.toggleClass("rtl", app.vault.getConfig("rightToLeft")); + viewEl.toggleClass("show-properties", "hidden" !== app.vault.getConfig("propertiesInDocument")); + const title = (_f = extra == null ? void 0 : extra.title) != null ? _f : file.basename; + viewEl.createEl("h1", { text: title }, (e) => { + var _a2; + e.addClass("__title__"); + e.style.display = config.showTitle ? "block" : "none"; + e.id = (_a2 = extra == null ? void 0 : extra.id) != null ? _a2 : ""; + }); + const cache = app.metadataCache.getFileCache(file); + const blocks = new Map(Object.entries((_g = cache == null ? void 0 : cache.blocks) != null ? _g : {})); + const lines = ((_h = data == null ? void 0 : data.split("\n")) != null ? _h : []).map((line, i) => { + for (const { + id, + position: { start, end } + } of blocks.values()) { + const blockid = `^${id}`; + if (line.includes(blockid) && i >= start.line && i <= end.line) { + blocks.delete(id); + return line.replace(blockid, ` ${blockid}`); + } + } + return line; + }); + [...blocks.values()].forEach(({ id, position: { start, end } }) => { + const idx = start.line; + lines[idx] = ` + +` + lines[idx]; + }); + const fragment = { + children: void 0, + appendChild(e) { + this.children = e == null ? void 0 : e.children; + throw new Error("exit"); + } + }; + const promises = []; + try { + await import_obsidian2.MarkdownRenderer.render(app, lines.join("\n"), fragment, file.path, comp); + } catch (error2) { + } + const el = createFragment(); + Array.from(fragment.children).forEach((item) => { + el.createDiv({}, (t) => { + return t.appendChild(item); + }); + }); + viewEl.appendChild(el); + await import_obsidian2.MarkdownRenderer.postProcess(app, { + docId: generateDocId(16), + sourcePath: file.path, + frontmatter: {}, + promises, + addChild: function(e) { + return comp.addChild(e); + }, + getSectionInfo: function() { + return null; + }, + containerEl: viewEl, + el: viewEl, + displayMode: true + }); + await Promise.all(promises); + printEl.findAll("a.internal-link").forEach((el2) => { + var _a2, _b2; + const [title2, anchor] = (_b2 = (_a2 = el2.dataset.href) == null ? void 0 : _a2.split("#")) != null ? _b2 : []; + if ((!title2 || (title2 == null ? void 0 : title2.length) == 0 || title2 == file.basename) && (anchor == null ? void 0 : anchor.startsWith("^"))) { + return; + } + el2.removeAttribute("href"); + }); + try { + await fixWaitRender(data, viewEl); + } catch (error2) { + console.warn("wait timeout"); + } + fixCanvasToImage(viewEl); + const doc = document.implementation.createHTMLDocument("document"); + doc.body.appendChild(printEl.cloneNode(true)); + printEl.detach(); + comp.unload(); + printEl.remove(); + doc.title = title; + console.log(`md render time:${(/* @__PURE__ */ new Date()).getTime() - startTime}ms`); + return { doc, frontMatter, file }; +} +function fixDoc(doc, title) { + const dest = modifyDest(doc); + fixAnchors(doc, dest, title); + encodeEmbeds(doc); + return doc; +} +function encodeEmbeds(doc) { + const spans = Array.from(doc.querySelectorAll("span.markdown-embed")).reverse(); + spans.forEach((span) => span.innerHTML = encodeURIComponent(span.innerHTML)); +} +async function fixWaitRender(data, viewEl) { + if (data.includes("```dataview") || data.includes("```gEvent") || data.includes("![[")) { + await sleep(2e3); + } + try { + await waitForDomChange(viewEl); + } catch (error2) { + await sleep(1e3); + } +} +function fixCanvasToImage(el) { + for (const canvas of Array.from(el.querySelectorAll("canvas"))) { + const data = canvas.toDataURL(); + const img = document.createElement("img"); + img.src = data; + copyAttributes(img, canvas.attributes); + img.className = "__canvas__"; + canvas.replaceWith(img); + } +} +function createWebview(scale2 = 1.25) { + const webview = document.createElement("webview"); + webview.src = `app://obsidian.md/help.html`; + webview.setAttribute( + "style", + `height:calc(${scale2} * 100%); + width: calc(${scale2} * 100%); + transform: scale(${1 / scale2}, ${1 / scale2}); + transform-origin: top left; + border: 1px solid #f2f2f2; + ` + ); + webview.nodeintegration = true; + return webview; +} +function waitForDomChange(target, timeout = 2e3, interval = 200) { + return new Promise((resolve, reject) => { + let timer; + const observer = new MutationObserver((m) => { + clearTimeout(timer); + timer = setTimeout(() => { + observer.disconnect(); + resolve(true); + }, interval); + }); + observer.observe(target, { + childList: true, + subtree: true, + attributes: true, + characterData: true + }); + setTimeout(() => { + observer.disconnect(); + reject(new Error(`timeout ${timeout}ms`)); + }, timeout); + }); +} + +// src/modal.ts +function fullWidthButton(button) { + button.buttonEl.setAttribute("style", `margin: "0 auto"; width: -webkit-fill-available`); +} +function setInputWidth(inputEl) { + inputEl.setAttribute("style", `width: 100px;`); +} +var ExportConfigModal = class extends import_obsidian3.Modal { + constructor(plugin, file, multiplePdf) { + var _a, _b, _c, _d, _e; + super(plugin.app); + this.canceled = true; + this.plugin = plugin; + this.file = file; + this.completed = false; + this.i18n = i18n_default.current; + this.docs = []; + this.scale = 0.75; + this.webviews = []; + this.multiplePdf = multiplePdf; + this.config = { + pageSize: "A4", + marginType: "1", + showTitle: (_a = plugin.settings.showTitle) != null ? _a : true, + open: true, + scale: 100, + landscape: false, + marginTop: "10", + marginBottom: "10", + marginLeft: "10", + marginRight: "10", + displayHeader: (_b = plugin.settings.displayHeader) != null ? _b : true, + displayFooter: (_c = plugin.settings.displayHeader) != null ? _c : true, + cssSnippet: "0", + ...(_e = (_d = plugin.settings) == null ? void 0 : _d.prevConfig) != null ? _e : {} + }; + } + getFileCache(file) { + return this.app.metadataCache.getFileCache(file); + } + async renderFiles() { + var _a, _b; + const app = this.plugin.app; + const docs = []; + if (this.file instanceof import_obsidian3.TFolder) { + const files = traverseFolder(this.file); + for (const file of files) { + docs.push(await renderMarkdown(app, file, this.config)); + } + } else { + const { doc, frontMatter, file } = await renderMarkdown(app, this.file, this.config); + docs.push({ doc, frontMatter, file }); + if (frontMatter.toc) { + const cache = this.getFileCache(this.file); + const files = (_b = (_a = cache == null ? void 0 : cache.links) == null ? void 0 : _a.map(({ link, displayText }) => { + const id = crypto.randomUUID(); + const elem = doc.querySelector(`a[data-href="${link}"]`); + if (elem) { + elem.href = `#${id}`; + } + return { + title: displayText, + file: this.app.metadataCache.getFirstLinkpathDest(link, this.file.path), + id + }; + }).filter((item) => item.file instanceof import_obsidian3.TFile)) != null ? _b : []; + for (const item of files) { + docs.push(await renderMarkdown(app, item.file, this.config, item)); + } + const leaf = this.app.workspace.getLeaf(); + await leaf.openFile(this.file); + } + } + if (!this.multiplePdf) { + this.mergeDoc(docs); + } + this.docs = docs.map(({ doc, ...rest }) => { + return { ...rest, doc: fixDoc(doc, doc.title) }; + }); + } + mergeDoc(docs) { + const { doc: doc0, frontMatter, file } = docs[0]; + const sections = []; + for (const { doc } of docs) { + const element = doc.querySelector(".markdown-preview-view"); + if (element) { + const section = doc0.createElement("section"); + Array.from(element.children).forEach((child) => { + section.appendChild(doc0.importNode(child, true)); + }); + sections.push(section); + } + } + const root = doc0.querySelector(".markdown-preview-view"); + if (root) { + root.innerHTML = ""; + } + sections.forEach((section) => { + root == null ? void 0 : root.appendChild(section); + }); + this.docs = [{ doc: doc0, frontMatter, file }]; + } + calcPageSize(element, config) { + var _a, _b, _c; + const { pageSize, pageWidth } = config != null ? config : this.config; + const el = element != null ? element : this.previewDiv; + let width = (_c = (_b = (_a = PageSize) == null ? void 0 : _a[pageSize]) == null ? void 0 : _b[0]) != null ? _c : parseFloat(pageWidth); + if (isNaN(width)) { + width = 210; + } + const scale2 = Math.floor(mm2px(width) / el.offsetWidth * 100) / 100; + this.webviews.forEach((wb) => { + wb.style.transform = `scale(${1 / scale2},${1 / scale2})`; + wb.style.width = `calc(${scale2} * 100%)`; + wb.style.height = `calc(${scale2} * 100%)`; + }); + this.scale = scale2; + return scale2; + } + async calcWebviewSize() { + await sleep(500); + this.webviews.forEach(async (e, i) => { + var _a; + const [width, height] = await e.executeJavaScript("[document.body.offsetWidth, document.body.offsetHeight]"); + const sizeEl = (_a = e.parentNode) == null ? void 0 : _a.querySelector(".print-size"); + if (sizeEl) { + sizeEl.innerHTML = `${width}\xD7${height}px +${px2mm(width)}\xD7${px2mm(height)}mm`; + } + }); + } + async togglePrintSize() { + var _a; + (_a = document.querySelectorAll(".print-size")) == null ? void 0 : _a.forEach((sizeEl) => { + if (this.config["pageSize"] == "Custom") { + sizeEl.style.visibility = "visible"; + } else { + sizeEl.style.visibility = "hidden"; + } + }); + } + makeWebviewJs(doc) { + return ` + document.body.innerHTML = decodeURIComponent(\`${encodeURIComponent(doc.body.innerHTML)}\`); + document.head.innerHTML = decodeURIComponent(\`${encodeURIComponent(document.head.innerHTML)}\`); + + // Function to recursively decode and replace innerHTML of span.markdown-embed elements + function decodeAndReplaceEmbed(element) { + // Replace the innerHTML with the decoded content + element.innerHTML = decodeURIComponent(element.innerHTML); + // Check if the new content contains further span.markdown-embed elements + const newEmbeds = element.querySelectorAll("span.markdown-embed"); + newEmbeds.forEach(decodeAndReplaceEmbed); + } + + // Start the process with all span.markdown-embed elements in the document + document.querySelectorAll("span.markdown-embed").forEach(decodeAndReplaceEmbed); + + document.body.setAttribute("class", \`${document.body.getAttribute("class")}\`) + document.body.setAttribute("style", \`${document.body.getAttribute("style")}\`) + document.body.addClass("theme-light"); + document.body.removeClass("theme-dark"); + document.title = \`${doc.title}\`; + `; + } + /** + * append webview + * @param e HTMLDivElement + * @param render Rerender or not + */ + async appendWebview(e, doc) { + const webview = createWebview(this.scale); + const preview = e.appendChild(webview); + this.webviews.push(preview); + this.preview = preview; + preview.addEventListener("dom-ready", async (e2) => { + this.completed = true; + getAllStyles().forEach(async (css) => { + await preview.insertCSS(css); + }); + if (this.config.cssSnippet && this.config.cssSnippet != "0") { + try { + const cssSnippet = await fs2.readFile(this.config.cssSnippet, { encoding: "utf8" }); + const printCss = cssSnippet.replaceAll(/@media print\s*{([^}]+)}/g, "$1"); + await preview.insertCSS(printCss); + await preview.insertCSS(cssSnippet); + } catch (error2) { + console.warn(error2); + } + } + await preview.executeJavaScript(this.makeWebviewJs(doc)); + getPatchStyle().forEach(async (css) => { + await preview.insertCSS(css); + }); + }); + } + async appendWebviews(e, render = true) { + var _a; + if (render) { + await this.renderFiles(); + } + e.empty(); + await Promise.all( + (_a = this.docs) == null ? void 0 : _a.map(async ({ doc }, i) => { + if (this.multiplePdf) { + e.createDiv({ + text: `${i + 1}-${doc.title}`, + attr: { class: "filename" } + }); + } + const div = e.createDiv({ attr: { class: "webview-wrapper" } }); + div.createDiv({ attr: { class: "print-size" } }); + await this.appendWebview(div, doc); + }) + ); + await this.calcWebviewSize(); + } + async onOpen() { + var _a, _b, _c; + this.contentEl.empty(); + this.containerEl.style.setProperty("--dialog-width", "60vw"); + this.titleEl.setText("Export to PDF"); + const wrapper = this.contentEl.createDiv({ attr: { id: "better-export-pdf" } }); + const title = (_c = (_a = this.file) == null ? void 0 : _a.basename) != null ? _c : (_b = this.file) == null ? void 0 : _b.name; + this.previewDiv = wrapper.createDiv({ attr: { class: "pdf-preview" } }, async (el) => { + el.empty(); + const resizeObserver = new ResizeObserver(() => { + this.calcPageSize(el); + }); + resizeObserver.observe(el); + await this.appendWebviews(el); + this.togglePrintSize(); + }); + const contentEl = wrapper.createDiv(); + contentEl.setAttribute("style", "width:320px;margin-left:16px;"); + contentEl.addEventListener("keyup", (event) => { + if (event.key === "Enter") { + handleExport(); + } + }); + this.generateForm(contentEl); + const handleExport = async () => { + this.plugin.settings.prevConfig = this.config; + await this.plugin.saveSettings(); + if (this.multiplePdf) { + const outputPath = await getOutputPath(title); + console.log("output:", outputPath); + if (outputPath) { + await Promise.all( + this.webviews.map(async (wb, i) => { + await exportToPDF( + `${outputPath}/${this.docs[i].file.basename}.pdf`, + { ...this.plugin.settings, ...this.config }, + wb, + this.docs[i] + ); + }) + ); + this.close(); + } + } else { + const outputFile = await getOutputFile(title, this.plugin.settings.isTimestamp); + if (outputFile) { + await exportToPDF(outputFile, { ...this.plugin.settings, ...this.config }, this.webviews[0], this.docs[0]); + this.close(); + } + } + }; + new import_obsidian3.Setting(contentEl).setHeading().addButton((button) => { + button.setButtonText("Export").onClick(handleExport); + button.setCta(); + fullWidthButton(button); + }); + new import_obsidian3.Setting(contentEl).setHeading().addButton((button) => { + button.setButtonText("Refresh").onClick(async () => { + await this.appendWebviews(this.previewDiv); + }); + fullWidthButton(button); + }); + const debugEl = new import_obsidian3.Setting(contentEl).setHeading().addButton((button) => { + button.setButtonText("Debug").onClick(async () => { + var _a2; + (_a2 = this.preview) == null ? void 0 : _a2.openDevTools(); + }); + fullWidthButton(button); + }); + debugEl.settingEl.hidden = !this.plugin.settings.debug; + } + generateForm(contentEl) { + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.filenameAsTitle).addToggle( + (toggle) => toggle.setTooltip("Include file name as title").setValue(this.config["showTitle"]).onChange(async (value) => { + this.config["showTitle"] = value; + this.webviews.forEach((wv, i) => { + var _a, _b; + wv.executeJavaScript(` + var _title = document.querySelector("h1.__title__"); + if (_title) { + _title.style.display = "${value ? "block" : "none"}"; + } + `); + const _title = (_b = (_a = this.docs[i]) == null ? void 0 : _a.doc) == null ? void 0 : _b.querySelector("h1.__title__"); + if (_title) { + _title.style.display = value ? "block" : "none"; + } + }); + }) + ); + const pageSizes = [ + "A0", + "A1", + "A2", + "A3", + "A4", + "A5", + "A6", + "Legal", + "Letter", + "Tabloid", + "Ledger", + "Custom" + ]; + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.pageSize).addDropdown((dropdown) => { + dropdown.addOptions(Object.fromEntries(pageSizes.map((size) => [size, size]))).setValue(this.config.pageSize).onChange(async (value) => { + this.config["pageSize"] = value; + if (value == "Custom") { + sizeEl.settingEl.hidden = false; + } else { + sizeEl.settingEl.hidden = true; + } + this.togglePrintSize(); + this.calcPageSize(); + await this.calcWebviewSize(); + }); + }); + const sizeEl = new import_obsidian3.Setting(contentEl).setName("Width/Height").addText((text) => { + setInputWidth(text.inputEl); + text.setPlaceholder("width").setValue(this.config["pageWidth"]).onChange( + (0, import_obsidian3.debounce)( + async (value) => { + this.config["pageWidth"] = value; + this.calcPageSize(); + await this.calcWebviewSize(); + }, + 500, + true + ) + ); + }).addText((text) => { + setInputWidth(text.inputEl); + text.setPlaceholder("height").setValue(this.config["pageHeight"]).onChange((value) => { + this.config["pageHeight"] = value; + }); + }); + sizeEl.settingEl.hidden = this.config["pageSize"] !== "Custom"; + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.margin).setDesc("The unit is millimeters.").addDropdown((dropdown) => { + dropdown.addOption("0", "None").addOption("1", "Default").addOption("2", "Small").addOption("3", "Custom").setValue(this.config["marginType"]).onChange(async (value) => { + this.config["marginType"] = value; + if (value == "3") { + topEl.settingEl.hidden = false; + btmEl.settingEl.hidden = false; + } else { + topEl.settingEl.hidden = true; + btmEl.settingEl.hidden = true; + } + }); + }); + const topEl = new import_obsidian3.Setting(contentEl).setName("Top/Bottom").addText((text) => { + setInputWidth(text.inputEl); + text.setPlaceholder("margin top").setValue(this.config["marginTop"]).onChange((value) => { + this.config["marginTop"] = value; + }); + }).addText((text) => { + setInputWidth(text.inputEl); + text.setPlaceholder("margin bottom").setValue(this.config["marginBottom"]).onChange((value) => { + this.config["marginBottom"] = value; + }); + }); + topEl.settingEl.hidden = this.config["marginType"] != "3"; + const btmEl = new import_obsidian3.Setting(contentEl).setName("Left/Right").addText((text) => { + setInputWidth(text.inputEl); + text.setPlaceholder("margin left").setValue(this.config["marginLeft"]).onChange((value) => { + this.config["marginLeft"] = value; + }); + }).addText((text) => { + setInputWidth(text.inputEl); + text.setPlaceholder("margin right").setValue(this.config["marginRight"]).onChange((value) => { + this.config["marginRight"] = value; + }); + }); + btmEl.settingEl.hidden = this.config["marginType"] != "3"; + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.downscalePercent).addSlider((slider) => { + slider.setLimits(0, 100, 1).setValue(this.config["scale"]).onChange(async (value) => { + this.config["scale"] = value; + slider.showTooltip(); + }); + }); + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.landscape).addToggle( + (toggle) => toggle.setTooltip("landscape").setValue(this.config["landscape"]).onChange(async (value) => { + this.config["landscape"] = value; + }) + ); + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.displayHeader).addToggle( + (toggle) => toggle.setTooltip("Display header").setValue(this.config["displayHeader"]).onChange(async (value) => { + this.config["displayHeader"] = value; + }) + ); + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.displayFooter).addToggle( + (toggle) => toggle.setTooltip("Display footer").setValue(this.config["displayFooter"]).onChange(async (value) => { + this.config["displayFooter"] = value; + }) + ); + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.openAfterExport).addToggle( + (toggle) => toggle.setTooltip("Open the exported file after exporting.").setValue(this.config["open"]).onChange(async (value) => { + this.config["open"] = value; + }) + ); + const snippets = this.cssSnippets(); + if (Object.keys(snippets).length > 0 && this.plugin.settings.enabledCss) { + new import_obsidian3.Setting(contentEl).setName(this.i18n.exportDialog.cssSnippets).addDropdown((dropdown) => { + dropdown.addOption("0", "Not select").addOptions(snippets).setValue(this.config["cssSnippet"]).onChange(async (value) => { + this.config["cssSnippet"] = value; + await this.appendWebviews(this.previewDiv, false); + }); + }); + } + } + onClose() { + const { contentEl } = this; + contentEl.empty(); + } + cssSnippets() { + var _a, _b; + const { snippets, enabledSnippets } = (_b = (_a = this.app) == null ? void 0 : _a.customCss) != null ? _b : {}; + const basePath = this.app.vault.adapter.basePath; + return Object.fromEntries( + snippets == null ? void 0 : snippets.filter((item) => !enabledSnippets.has(item)).map((name) => { + const file = import_path.default.join(basePath, ".obsidian/snippets", name + ".css"); + return [file, name]; + }) + ); + } +}; + +// src/setting.ts +var import_obsidian4 = require("obsidian"); +function setAttributes(element, attributes) { + for (const key in attributes) { + element.setAttribute(key, attributes[key]); + } +} +var renderBuyMeACoffeeBadge = (contentEl, width = 175) => { + const linkEl = contentEl.createEl("a", { + href: "https://www.buymeacoffee.com/l1xnan" + }); + const imgEl = linkEl.createEl("img"); + imgEl.src = "https://img.buymeacoffee.com/button-api/?text=Buy me a coffee&emoji=&slug=nathangeorge&button_colour=6a8696&font_colour=ffffff&font_family=Poppins&outline_colour=000000&coffee_colour=FFDD00"; + imgEl.alt = "Buy me a coffee"; + imgEl.width = width; +}; +var ConfigSettingTab = class extends import_obsidian4.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + this.i18n = i18n_default.current; + } + display() { + const { containerEl } = this; + containerEl.empty(); + const supportDesc = new DocumentFragment(); + supportDesc.createDiv({ + text: "Support the continued development of this plugin." + }); + new import_obsidian4.Setting(containerEl).setDesc(supportDesc); + renderBuyMeACoffeeBadge(containerEl); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.showTitle).addToggle( + (toggle) => toggle.setTooltip(this.i18n.settings.showTitle).setValue(this.plugin.settings.showTitle).onChange(async (value) => { + this.plugin.settings.showTitle = value; + this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.displayHeader).addToggle( + (toggle) => toggle.setTooltip("Display header").setValue(this.plugin.settings.displayHeader).onChange(async (value) => { + this.plugin.settings.displayHeader = value; + this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.displayFooter).addToggle( + (toggle) => toggle.setTooltip("Display footer").setValue(this.plugin.settings.displayFooter).onChange(async (value) => { + this.plugin.settings.displayFooter = value; + this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.printBackground).setDesc("Whether to print background graphics").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.printBackground).onChange(async (value) => { + this.plugin.settings.printBackground = value; + this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(containerEl).setName("Generate tagged PDF").setDesc( + "Whether or not to generate a tagged (accessible) PDF. Defaults to false. As this property is experimental, the generated PDF may not adhere fully to PDF/UA and WCAG standards." + ).addToggle( + (toggle) => toggle.setValue(this.plugin.settings.generateTaggedPDF).onChange(async (value) => { + this.plugin.settings.generateTaggedPDF = value; + this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.maxLevel).addDropdown((dropdown) => { + dropdown.addOptions(Object.fromEntries(["1", "2", "3", "4", "5", "6"].map((level) => [level, `h${level}`]))).setValue(this.plugin.settings.maxLevel).onChange(async (value) => { + this.plugin.settings.maxLevel = value; + this.plugin.saveSettings(); + }); + }); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.displayMetadata).setDesc("Add frontMatter(title, author, keywords, subject creator, etc) to pdf metadata").addToggle( + (toggle) => toggle.setValue(this.plugin.settings.displayMetadata).onChange(async (value) => { + this.plugin.settings.displayMetadata = value; + this.plugin.saveSettings(); + }) + ); + new import_obsidian4.Setting(containerEl).setName("Advanced").setHeading(); + const headerContentAreaSetting = new import_obsidian4.Setting(containerEl); + headerContentAreaSetting.settingEl.setAttribute("style", "display: grid; grid-template-columns: 1fr;"); + headerContentAreaSetting.setName(this.i18n.settings.headerTemplate).setDesc( + 'HTML template for the print header. Should be valid HTML markup with following classes used to inject printing values into them: date (formatted print date), title (document title), url (document location), pageNumber (current page number) and totalPages (total pages in the document). For example, would generate span containing the title.' + ); + const hederContentArea = new import_obsidian4.TextAreaComponent(headerContentAreaSetting.controlEl); + setAttributes(hederContentArea.inputEl, { + style: "margin-top: 12px; width: 100%; height: 6vh;" + }); + hederContentArea.setValue(this.plugin.settings.headerTemplate).onChange(async (value) => { + this.plugin.settings.headerTemplate = value; + this.plugin.saveSettings(); + }); + const footerContentAreaSetting = new import_obsidian4.Setting(containerEl); + footerContentAreaSetting.settingEl.setAttribute("style", "display: grid; grid-template-columns: 1fr;"); + footerContentAreaSetting.setName(this.i18n.settings.footerTemplate).setDesc("HTML template for the print footer. Should use the same format as the headerTemplate."); + const footerContentArea = new import_obsidian4.TextAreaComponent(footerContentAreaSetting.controlEl); + setAttributes(footerContentArea.inputEl, { + style: "margin-top: 12px; width: 100%; height: 6vh;" + }); + footerContentArea.setValue(this.plugin.settings.footerTemplate).onChange(async (value) => { + this.plugin.settings.footerTemplate = value; + this.plugin.saveSettings(); + }); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.isTimestamp).setDesc("Add timestamp to output file name").addToggle((cb) => { + cb.setValue(this.plugin.settings.isTimestamp).onChange(async (value) => { + this.plugin.settings.isTimestamp = value; + await this.plugin.saveSettings(); + }); + }); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.enabledCss).setDesc("Select the css snippet that are not enabled").addToggle((cb) => { + cb.setValue(this.plugin.settings.enabledCss).onChange(async (value) => { + this.plugin.settings.enabledCss = value; + await this.plugin.saveSettings(); + }); + }); + new import_obsidian4.Setting(containerEl).setName("Debug").setHeading(); + new import_obsidian4.Setting(containerEl).setName(this.i18n.settings.debugMode).setDesc("This is useful for troubleshooting.").addToggle((cb) => { + cb.setValue(this.plugin.settings.debug).onChange(async (value) => { + this.plugin.settings.debug = value; + await this.plugin.saveSettings(); + }); + }); + } +}; + +// src/main.ts +var isDev = false; +var DEFAULT_SETTINGS = { + showTitle: true, + maxLevel: "6", + displayHeader: true, + displayFooter: true, + headerTemplate: `
`, + footerTemplate: `
/
`, + printBackground: false, + generateTaggedPDF: false, + displayMetadata: false, + debug: false, + isTimestamp: false, + enabledCss: false +}; +var BetterExportPdfPlugin = class extends import_obsidian5.Plugin { + constructor(app, manifest) { + super(app, manifest); + this.i18n = i18n_default.current; + } + async onload() { + await this.loadSettings(); + this.registerCommand(); + this.registerSetting(); + this.registerEvents(); + } + registerCommand() { + this.addCommand({ + id: "export-current-file-to-pdf", + name: this.i18n.exportCurrentFile, + checkCallback: (checking) => { + const view = this.app.workspace.getActiveViewOfType(import_obsidian5.MarkdownView); + const file = view == null ? void 0 : view.file; + if (!file) { + return false; + } + if (checking) { + return true; + } + new ExportConfigModal(this, file).open(); + return true; + } + }); + } + registerSetting() { + this.addSettingTab(new ConfigSettingTab(this.app, this)); + } + registerEvents() { + this.registerEvent( + this.app.workspace.on("file-menu", (menu, file) => { + let title = file instanceof import_obsidian5.TFolder ? "Export folder to PDF" : "Better Export PDF"; + if (isDev) { + title = `${title} (dev)`; + } + menu.addItem((item) => { + item.setTitle(title).setIcon("download").setSection("action").onClick(async () => { + new ExportConfigModal(this, file).open(); + }); + }); + }) + ); + this.registerEvent( + this.app.workspace.on("file-menu", (menu, file) => { + if (file instanceof import_obsidian5.TFolder) { + let title = "Export each file to PDF"; + if (isDev) { + title = `${title} (dev)`; + } + menu.addItem((item) => { + item.setTitle(title).setIcon("download").setSection("action").onClick(async () => { + new ExportConfigModal(this, file, true).open(); + }); + }); + } + }) + ); + } + onunload() { + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } + changeConfig() { + var _a; + const theme = "obsidian" === ((_a = this.app.vault) == null ? void 0 : _a.getConfig("theme")); + if (theme) { + document.body.addClass("theme-light"); + document.body.removeClass("theme-dark"); + } + document.body.removeClass("theme-dark"); + const node = document.body.createDiv("print"); + const reset = function() { + node.detach(); + if (theme) { + document.body.removeClass("theme-light"); + document.body.addClass("theme-dark"); + } + }; + node.addEventListener("click", reset); + const el = document.body.createDiv("print"); + const el2 = el.createDiv("markdown-preview-view markdown-rendered"); + el2.toggleClass("rtl", this.app.vault.getConfig("rightToLeft")); + el2.toggleClass("show-frontmatter", this.app.vault.getConfig("showFrontmatter")); + el2.createEl("h1", { + text: "xxxxx" + // a.basename + }); + } +}; +/*! Bundled license information: + +tslib/tslib.es6.js: + (*! ***************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** *) +*/ + +/* nosourcemap */ \ No newline at end of file diff --git a/.obsidian/plugins/better-export-pdf/manifest.json b/.obsidian/plugins/better-export-pdf/manifest.json new file mode 100644 index 0000000..d101cb3 --- /dev/null +++ b/.obsidian/plugins/better-export-pdf/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "better-export-pdf", + "name": "Better Export PDF", + "version": "1.9.2", + "minAppVersion": "0.15.0", + "description": "Export your notes to PDF, support export preview, add bookmarks outline and header/footer.", + "author": "l1xnan", + "authorUrl": "https://github.com/l1xnan", + "fundingUrl": "https://www.buymeacoffee.com/l1xnan", + "isDesktopOnly": true +} diff --git a/.obsidian/plugins/better-export-pdf/styles.css b/.obsidian/plugins/better-export-pdf/styles.css new file mode 100644 index 0000000..1ae02d6 --- /dev/null +++ b/.obsidian/plugins/better-export-pdf/styles.css @@ -0,0 +1,52 @@ +#better-export-pdf { + display: flex; + flex-direction: row; + height: 75vh; +} + +#better-export-pdf .pdf-preview { + flex: auto; + position: relative; + display: flex; + flex-direction: column; + overflow-x: hidden; + overflow-y: scroll; + align-content: flex-start; +} + +#better-export-pdf .pdf-preview .webview-wrapper { + position: relative; + height: 100%; + width: 100%; +} + +#better-export-pdf .pdf-preview .print-size { + position: absolute; + right: 8px; + top: 8px; + z-index: 99; + font-size: 0.6rem; + white-space: pre-wrap; + text-align: right; + visibility: hidden; +} + +#better-export-pdf .pdf-preview > div { + flex: 1; + height: 100%; + width: 100%; +} + +#better-export-pdf .pdf-preview .filename { + font-size: 0.75rem; + color: var(--color-base-60); +} +#better-export-pdf .pdf-preview .filename:not(:first-child) { + padding-top: calc(var(--p-spacing)); +} + +#better-export-pdf webview { + flex: 1; + height: 100%; + width: 100%; +} diff --git a/.obsidian/plugins/d2-obsidian/main.js b/.obsidian/plugins/d2-obsidian/main.js new file mode 100644 index 0000000..cc367f4 --- /dev/null +++ b/.obsidian/plugins/d2-obsidian/main.js @@ -0,0 +1,533 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin: https://github.com/terrastruct/d2-obsidian +*/ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/lodash.debounce/index.js +var require_lodash = __commonJS({ + "node_modules/lodash.debounce/index.js"(exports, module2) { + var FUNC_ERROR_TEXT = "Expected a function"; + var NAN = 0 / 0; + var symbolTag = "[object Symbol]"; + var reTrim = /^\s+|\s+$/g; + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + var reIsBinary = /^0b[01]+$/i; + var reIsOctal = /^0o[0-7]+$/i; + var freeParseInt = parseInt; + var freeGlobal = typeof global == "object" && global && global.Object === Object && global; + var freeSelf = typeof self == "object" && self && self.Object === Object && self; + var root = freeGlobal || freeSelf || Function("return this")(); + var objectProto = Object.prototype; + var objectToString = objectProto.toString; + var nativeMax = Math.max; + var nativeMin = Math.min; + var now = function() { + return root.Date.now(); + }; + function debounce2(func, wait, options) { + var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true; + if (typeof func != "function") { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = "maxWait" in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = "trailing" in options ? !!options.trailing : trailing; + } + function invokeFunc(time) { + var args = lastArgs, thisArg = lastThis; + lastArgs = lastThis = void 0; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + function leadingEdge(time) { + lastInvokeTime = time; + timerId = setTimeout(timerExpired, wait); + return leading ? invokeFunc(time) : result; + } + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall; + return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2; + } + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime; + return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait; + } + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + timerId = setTimeout(timerExpired, remainingWait(time)); + } + function trailingEdge(time) { + timerId = void 0; + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = void 0; + return result; + } + function cancel() { + if (timerId !== void 0) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = void 0; + } + function flush() { + return timerId === void 0 ? result : trailingEdge(now()); + } + function debounced() { + var time = now(), isInvoking = shouldInvoke(time); + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + if (isInvoking) { + if (timerId === void 0) { + return leadingEdge(lastCallTime); + } + if (maxing) { + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === void 0) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + function isObject(value) { + var type = typeof value; + return !!value && (type == "object" || type == "function"); + } + function isObjectLike(value) { + return !!value && typeof value == "object"; + } + function isSymbol(value) { + return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag; + } + function toNumber(value) { + if (typeof value == "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == "function" ? value.valueOf() : value; + value = isObject(other) ? other + "" : other; + } + if (typeof value != "string") { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ""); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; + } + module2.exports = debounce2; + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => D2Plugin +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian3 = require("obsidian"); + +// src/settings.ts +var import_obsidian = require("obsidian"); + +// src/constants.ts +var LAYOUT_ENGINES = { + DAGRE: { + value: "dagre", + label: "dagre" + }, + ELK: { + value: "elk", + label: "ELK" + }, + TALA: { + value: "tala", + label: "TALA" + } +}; +var RecompileIcon = ` + + + + + +`; + +// src/settings.ts +var DEFAULT_SETTINGS = { + layoutEngine: "dagre", + debounce: 500, + theme: 0, + apiToken: "", + d2Path: "", + pad: 100, + sketch: false, + containerHeight: 800 +}; +var D2SettingsTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + addTALASettings() { + const talaSettings = this.containerEl.createEl("div"); + talaSettings.createEl("h3", { + text: "TALA settings" + }); + new import_obsidian.Setting(talaSettings).setName("API token").setDesc('To use TALA, copy your API token here or in ~/.local/state/tstruct/auth.json under the field "api_token"').addText((text) => text.setPlaceholder("tstruct_...").setValue(this.plugin.settings.apiToken).setDisabled(this.plugin.settings.layoutEngine !== LAYOUT_ENGINES.TALA.value).onChange(async (value) => { + if (value && !value.startsWith("tstruct_")) { + new import_obsidian.Notice("Invalid API token"); + } else { + this.plugin.settings.apiToken = value; + await this.plugin.saveSettings(); + } + })); + this.talaSettings = talaSettings; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h1", { text: "D2 plugin settings" }); + new import_obsidian.Setting(containerEl).setName("Layout engine").setDesc('Available layout engines include "dagre", "ELK", and "TALA" (TALA must be installed separately from D2)').addDropdown((dropdown) => { + dropdown.addOption(LAYOUT_ENGINES.DAGRE.value, LAYOUT_ENGINES.DAGRE.label).addOption(LAYOUT_ENGINES.ELK.value, LAYOUT_ENGINES.ELK.label).addOption(LAYOUT_ENGINES.TALA.value, LAYOUT_ENGINES.TALA.label).setValue(this.plugin.settings.layoutEngine).onChange(async (value) => { + var _a; + this.plugin.settings.layoutEngine = value; + await this.plugin.saveSettings(); + if (value === LAYOUT_ENGINES.TALA.value) { + this.addTALASettings(); + } else { + (_a = this.talaSettings) == null ? void 0 : _a.remove(); + } + }); + }); + new import_obsidian.Setting(containerEl).setName("Theme ID").setDesc("Available themes are located at https://github.com/terrastruct/d2/tree/master/d2themes").addText((text) => text.setPlaceholder("Enter a theme ID").setValue(String(this.plugin.settings.theme)).onChange(async (value) => { + if (!isNaN(Number(value)) || value === "") { + this.plugin.settings.theme = Number(value || DEFAULT_SETTINGS.theme); + await this.plugin.saveSettings(); + } else { + new import_obsidian.Notice("Please specify a valid number"); + } + })); + new import_obsidian.Setting(containerEl).setName("Pad").setDesc("Pixels padded around the rendered diagram").addText((text) => text.setPlaceholder(String(DEFAULT_SETTINGS.pad)).setValue(String(this.plugin.settings.pad)).onChange(async (value) => { + if (isNaN(Number(value))) { + new import_obsidian.Notice("Please specify a valid number"); + this.plugin.settings.pad = Number(DEFAULT_SETTINGS.pad); + } else if (value === "") { + this.plugin.settings.pad = Number(DEFAULT_SETTINGS.pad); + } else { + this.plugin.settings.pad = Number(value); + } + await this.plugin.saveSettings(); + })); + new import_obsidian.Setting(containerEl).setName("Sketch mode").setDesc("Render the diagram to look like it was sketched by hand").addToggle((toggle) => toggle.setValue(this.plugin.settings.sketch).onChange(async (value) => { + this.plugin.settings.sketch = value; + await this.plugin.saveSettings(); + })); + new import_obsidian.Setting(containerEl).setName("Container height").setDesc("Diagram max render height in pixels (Requires d2 v0.2.2 and up)").addText((text) => text.setPlaceholder(String(DEFAULT_SETTINGS.containerHeight)).setValue(String(this.plugin.settings.containerHeight)).onChange(async (value) => { + if (isNaN(Number(value))) { + new import_obsidian.Notice("Please specify a valid number"); + this.plugin.settings.containerHeight = Number(DEFAULT_SETTINGS.containerHeight); + } else if (value === "") { + this.plugin.settings.containerHeight = Number(DEFAULT_SETTINGS.containerHeight); + } else { + this.plugin.settings.containerHeight = Number(value); + } + await this.plugin.saveSettings(); + })); + new import_obsidian.Setting(containerEl).setName("Debounce").setDesc("How often should the diagram refresh in milliseconds (min 100)").addText((text) => text.setPlaceholder(String(DEFAULT_SETTINGS.debounce)).setValue(String(this.plugin.settings.debounce)).onChange(async (value) => { + if (isNaN(Number(value))) { + new import_obsidian.Notice("Please specify a valid number"); + this.plugin.settings.debounce = Number(DEFAULT_SETTINGS.debounce); + } else if (value === "") { + this.plugin.settings.debounce = Number(DEFAULT_SETTINGS.debounce); + } else if (Number(value) < 100) { + new import_obsidian.Notice("The value must be greater than 100"); + this.plugin.settings.debounce = Number(DEFAULT_SETTINGS.debounce); + } else { + this.plugin.settings.debounce = Number(value); + } + await this.plugin.saveSettings(); + })); + new import_obsidian.Setting(containerEl).setName("Path (optional)").setDesc("Customize the local path to the directory `d2` is installed in (ex. if d2 is located at `/usr/local/bin/d2`, then the path is `/usr/local/bin`). This is only necessary if `d2` is not found automatically by the plugin (but is installed).").addText((text) => { + text.setPlaceholder("/usr/local/Cellar").setValue(this.plugin.settings.d2Path).onChange(async (value) => { + this.plugin.settings.d2Path = value; + await this.plugin.saveSettings(); + }); + }); + if (this.plugin.settings.layoutEngine === LAYOUT_ENGINES.TALA.value) { + this.addTALASettings(); + } + } +}; + +// src/processor.ts +var import_obsidian2 = require("obsidian"); +var import_child_process = require("child_process"); +var import_path = require("path"); +var import_lodash = __toESM(require_lodash()); +var import_os = __toESM(require("os")); +var D2Processor = class { + constructor(plugin) { + this.attemptExport = async (source, el, ctx) => { + var _a; + el.createEl("h6", { + text: "Generating D2 diagram...", + cls: "D2__Loading" + }); + const pageContainer = ctx.containerEl; + let pageID = pageContainer.dataset.pageID; + if (!pageID) { + pageID = Math.floor(Math.random() * Date.now()).toString(); + pageContainer.dataset.pageID = pageID; + } + let debouncedFunc = this.debouncedMap.get(pageID); + if (!debouncedFunc) { + await this.export(source, el, ctx); + debouncedFunc = (0, import_lodash.default)(this.export, this.plugin.settings.debounce, { + leading: true + }); + this.debouncedMap.set(pageID, debouncedFunc); + return; + } + (_a = this.abortControllerMap.get(pageID)) == null ? void 0 : _a.abort(); + const newAbortController = new AbortController(); + this.abortControllerMap.set(pageID, newAbortController); + await debouncedFunc(source, el, ctx, newAbortController.signal); + }; + this.isValidUrl = (urlString) => { + let url; + try { + url = new URL(urlString); + } catch (e) { + return false; + } + return url.protocol === "http:" || url.protocol === "https:"; + }; + this.formatLinks = (svgEl) => { + const links = svgEl.querySelectorAll("a"); + links.forEach((link) => { + var _a; + const href = (_a = link.getAttribute("href")) != null ? _a : ""; + if (!this.isValidUrl(href)) { + link.classList.add("internal-link"); + link.setAttribute("data-href", href); + link.setAttribute("target", "_blank"); + link.setAttribute("rel", "noopener"); + } + }); + }; + this.sanitizeSVGIDs = (svgEl, docID) => { + const overrides = svgEl.querySelectorAll("marker, mask, filter"); + const overrideIDs = []; + overrides.forEach((override) => { + const id = override.getAttribute("id"); + if (id) { + overrideIDs.push(id); + } + }); + return overrideIDs.reduce((svgHTML, overrideID) => { + return svgHTML.replaceAll(overrideID, [overrideID, docID].join("-")); + }, svgEl.outerHTML); + }; + this.export = async (source, el, ctx, signal) => { + try { + const image = await this.generatePreview(source, signal); + if (image) { + el.empty(); + this.prevImage = image; + this.insertImage(image, el, ctx); + const button = new import_obsidian2.ButtonComponent(el).setClass("Preview__Recompile").setIcon("recompile").onClick((e) => { + e.preventDefault(); + e.stopPropagation(); + el.empty(); + this.attemptExport(source, el, ctx); + }); + button.buttonEl.createEl("span", { + text: "Recompile" + }); + } + } catch (err) { + el.empty(); + const errorEl = el.createEl("pre", { + cls: "markdown-rendered pre Preview__Error" + }); + errorEl.createEl("code", { + text: "D2 Compilation Error:", + cls: "Preview__Error--Title" + }); + errorEl.createEl("code", { + text: err.message + }); + if (this.prevImage) { + this.insertImage(this.prevImage, el, ctx); + } + } finally { + const pageContainer = ctx.containerEl; + this.abortControllerMap.delete(pageContainer.dataset.id); + } + }; + this.plugin = plugin; + this.debouncedMap = /* @__PURE__ */ new Map(); + this.abortControllerMap = /* @__PURE__ */ new Map(); + } + insertImage(image, el, ctx) { + const parser = new DOMParser(); + const svg = parser.parseFromString(image, "image/svg+xml"); + const containerEl = el.createDiv(); + const svgEl = svg.documentElement; + svgEl.style.maxHeight = `${this.plugin.settings.containerHeight}px`; + svgEl.style.maxWidth = "100%"; + svgEl.style.height = "fit-content"; + svgEl.style.width = "fit-content"; + this.formatLinks(svgEl); + containerEl.innerHTML = this.sanitizeSVGIDs(svgEl, ctx.docId); + } + async generatePreview(source, signal) { + var _a, _b; + const pathArray = [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin"]; + if (import_os.default.platform() === "win32") { + pathArray.push(`C:Program FilesD2`); + } else { + pathArray.push(`${process.env.HOME}/.local/bin`); + } + let GOPATH = ""; + try { + GOPATH = (0, import_child_process.execSync)("go env GOPATH", { + env: { + ...process.env, + PATH: pathArray.join(import_path.delimiter) + } + }).toString(); + } catch (error) { + } + if (GOPATH) { + pathArray.push(`${GOPATH.replace("\n", "")}/bin`); + } + if (this.plugin.settings.d2Path) { + pathArray.push(this.plugin.settings.d2Path); + } + const options = { + ...process.env, + env: { + PATH: pathArray.join(import_path.delimiter) + }, + signal + }; + if (this.plugin.settings.apiToken) { + options.env.TSTRUCT_TOKEN = this.plugin.settings.apiToken; + } + let args = [ + `d2`, + "-", + `--theme=${this.plugin.settings.theme}`, + `--layout=${this.plugin.settings.layoutEngine}`, + `--pad=${this.plugin.settings.pad}`, + `--sketch=${this.plugin.settings.sketch}`, + "--bundle=false", + "--scale=1" + ]; + const cmd = args.join(" "); + const child = (0, import_child_process.exec)(cmd, options); + (_a = child.stdin) == null ? void 0 : _a.write(source); + (_b = child.stdin) == null ? void 0 : _b.end(); + let stdout; + let stderr; + if (child.stdout) { + child.stdout.on("data", (data) => { + if (stdout === void 0) { + stdout = data; + } else { + stdout += data; + } + }); + } + if (child.stderr) { + child.stderr.on("data", (data) => { + if (stderr === void 0) { + stderr = data; + } else { + stderr += data; + } + }); + } + return new Promise((resolve, reject) => { + child.on("error", reject); + child.on("close", (code) => { + if (code === 0) { + resolve(stdout); + return; + } else if (stderr) { + console.error(stderr); + reject(new Error(stderr)); + } else if (stdout) { + console.error(stdout); + reject(new Error(stdout)); + } + }); + }); + } +}; + +// src/main.ts +var D2Plugin = class extends import_obsidian3.Plugin { + async onload() { + (0, import_obsidian3.addIcon)("recompile", RecompileIcon); + await this.loadSettings(); + this.addSettingTab(new D2SettingsTab(this.app, this)); + const processor = new D2Processor(this); + this.registerMarkdownCodeBlockProcessor("d2", processor.attemptExport); + this.processor = processor; + } + onunload() { + const abortControllers = this.processor.abortControllerMap.values(); + Array.from(abortControllers).forEach((controller) => { + controller.abort(); + }); + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } +}; diff --git a/.obsidian/plugins/d2-obsidian/manifest.json b/.obsidian/plugins/d2-obsidian/manifest.json new file mode 100644 index 0000000..4bffa8b --- /dev/null +++ b/.obsidian/plugins/d2-obsidian/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "d2-obsidian", + "name": "D2", + "version": "1.1.4", + "minAppVersion": "0.15.0", + "description": "The official D2 plugin for Obsidian. D2 is a modern diagram scripting language that turns text to diagrams.", + "author": "Terrastruct", + "authorUrl": "https://d2lang.com", + "isDesktopOnly": true +} diff --git a/.obsidian/plugins/d2-obsidian/styles.css b/.obsidian/plugins/d2-obsidian/styles.css new file mode 100644 index 0000000..46e334a --- /dev/null +++ b/.obsidian/plugins/d2-obsidian/styles.css @@ -0,0 +1,49 @@ +.D2__Loading { + font-style: italic; +} + +.Preview__Error--Title { + color: #be0b41 !important; +} + +.Preview__Error { + display: flex; + flex-direction: column; + white-space: pre; + white-space: pre-wrap; +} + +.Preview__Recompile { + position: absolute; + top: 4px; + left: 4px; + height: 24px; + padding: 6px; + background-color: white !important; + color: #2e3346; + display: flex; + gap: 4px; + box-shadow: none !important; + border: 1px solid #dee1eb; + filter: drop-shadow(1px 1px 4px rgba(31, 36, 58, 0.08)); +} + +.Preview__Recompile:hover { + filter: drop-shadow(2px 2px 16px rgba(31, 36, 58, 0.12)); + cursor: pointer; +} + +.Preview__Recompile > .svg-icon { + height: 12px !important; + width: 12px !important; +} + +.block-language-d2 { + position: relative; +} + +@media print { + .Preview__Recompile { + display: none; + } +} diff --git a/.obsidian/plugins/execute-code/data.json b/.obsidian/plugins/execute-code/data.json new file mode 100644 index 0000000..cab2a65 --- /dev/null +++ b/.obsidian/plugins/execute-code/data.json @@ -0,0 +1,169 @@ +{ + "lastOpenLanguageTab": "c", + "timeout": 10000, + "allowInput": true, + "wslMode": false, + "shellWSLMode": false, + "onlyCurrentBlock": false, + "nodePath": "node", + "nodeArgs": "", + "jsFileExtension": "js", + "jsInject": "", + "tsPath": "ts-node", + "tsArgs": "", + "tsInject": "", + "leanPath": "lean", + "leanArgs": "", + "leanInject": "", + "luaPath": "lua", + "luaArgs": "", + "luaFileExtension": "lua", + "luaInject": "", + "dartPath": "dart", + "dartArgs": "", + "dartFileExtension": "dart", + "dartInject": "", + "csPath": "dotnet-script", + "csArgs": "", + "csFileExtension": "csx", + "csInject": "", + "pythonPath": "python", + "pythonArgs": "", + "pythonEmbedPlots": true, + "pythonFileExtension": "py", + "pythonInject": "", + "shellPath": "bash", + "shellArgs": "", + "shellFileExtension": "sh", + "shellInject": "", + "batchPath": "call", + "batchArgs": "", + "batchFileExtension": "bat", + "batchInject": "", + "groovyPath": "groovy", + "groovyArgs": "", + "groovyFileExtension": "groovy", + "groovyInject": "", + "golangPath": "go", + "golangArgs": "run", + "golangFileExtension": "go", + "goInject": "", + "javaPath": "java", + "javaArgs": "-ea", + "javaFileExtension": "java", + "javaInject": "", + "maxPrologAnswers": 15, + "prologInject": "", + "powershellPath": "powershell", + "powershellArgs": "-file", + "powershellFileExtension": "ps1", + "powershellInject": "$OutputEncoding = [console]::InputEncoding = [console]::OutputEncoding = New-Object System.Text.UTF8Encoding", + "powershellEncoding": "latin1", + "cargoPath": "cargo", + "cargoEvalArgs": "", + "rustInject": "", + "cppRunner": "cling", + "cppFileExtension": "cpp", + "cppInject": "", + "cppArgs": "", + "cppUseMain": false, + "clingPath": "gcc", + "clingArgs": "", + "clingStd": "c++17", + "rustFileExtension": "rs", + "RPath": "Rscript", + "RArgs": "", + "REmbedPlots": true, + "RFileExtension": "R", + "rInject": "", + "kotlinPath": "kotlinc", + "kotlinArgs": "-script", + "kotlinFileExtension": "kts", + "kotlinInject": "", + "swiftPath": "swift", + "swiftArgs": "", + "swiftFileExtension": "swift", + "swiftInject": "", + "runghcPath": "runghc", + "ghcPath": "ghc", + "ghciPath": "ghci", + "useGhci": false, + "haskellInject": "", + "mathematicaPath": "wolframscript", + "mathematicaArgs": "-file", + "mathematicaFileExtension": "wls", + "mathematicaInject": "", + "scalaPath": "scala", + "scalaArgs": "", + "scalaFileExtension": "scala", + "scalaInject": "", + "racketPath": "racket", + "racketArgs": "", + "racketFileExtension": "rkt", + "racketInject": "#lang racket", + "fsharpPath": "dotnet", + "fsharpArgs": "", + "fsharpInject": "", + "fsharpFileExtension": "fsx", + "cArgs": "", + "cUseMain": true, + "cInject": "", + "rubyPath": "ruby", + "rubyArgs": "", + "rubyFileExtension": "rb", + "rubyInject": "", + "sqlPath": "psql", + "sqlArgs": "-d -U -f", + "sqlInject": "", + "octavePath": "octave", + "octaveArgs": "-q", + "octaveFileExtension": "m", + "octaveInject": "figure('visible','off') # Necessary to embed plots", + "maximaPath": "maxima", + "maximaArgs": "-qb", + "maximaFileExtension": "mx", + "maximaInject": "", + "applescriptPath": "osascript", + "applescriptArgs": "", + "applescriptFileExtension": "scpt", + "applescriptInject": "", + "zigPath": "zig", + "zigArgs": "run", + "zigInject": "", + "ocamlPath": "ocaml", + "ocamlArgs": "", + "ocamlInject": "", + "jsInteractive": true, + "tsInteractive": false, + "csInteractive": false, + "leanInteractive": false, + "luaInteractive": false, + "dartInteractive": false, + "pythonInteractive": true, + "cppInteractive": false, + "prologInteractive": false, + "shellInteractive": false, + "batchInteractive": false, + "bashInteractive": false, + "groovyInteractive": false, + "rInteractive": false, + "goInteractive": false, + "rustInteractive": false, + "javaInteractive": false, + "powershellInteractive": false, + "kotlinInteractive": false, + "swiftInteractive": false, + "mathematicaInteractive": false, + "haskellInteractive": false, + "scalaInteractive": false, + "fsharpInteractive": false, + "cInteractive": false, + "racketInteractive": false, + "rubyInteractive": false, + "sqlInteractive": false, + "octaveInteractive": false, + "maximaInteractive": false, + "applescriptInteractive": false, + "zigInteractive": false, + "ocamlInteractive": false +} \ No newline at end of file diff --git a/.obsidian/plugins/execute-code/main.js b/.obsidian/plugins/execute-code/main.js new file mode 100644 index 0000000..35eca79 --- /dev/null +++ b/.obsidian/plugins/execute-code/main.js @@ -0,0 +1,13328 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __reflectGet = Reflect.get; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj); +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// node_modules/json5/dist/index.js +var require_dist = __commonJS({ + "node_modules/json5/dist/index.js"(exports, module2) { + (function(global2, factory) { + typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global2.JSON5 = factory(); + })(exports, function() { + "use strict"; + function createCommonjsModule(fn, module3) { + return module3 = { exports: {} }, fn(module3, module3.exports), module3.exports; + } + var _global = createCommonjsModule(function(module3) { + var global2 = module3.exports = typeof window != "undefined" && window.Math == Math ? window : typeof self != "undefined" && self.Math == Math ? self : Function("return this")(); + if (typeof __g == "number") { + __g = global2; + } + }); + var _core = createCommonjsModule(function(module3) { + var core = module3.exports = { version: "2.6.5" }; + if (typeof __e == "number") { + __e = core; + } + }); + var _core_1 = _core.version; + var _isObject = function(it) { + return typeof it === "object" ? it !== null : typeof it === "function"; + }; + var _anObject = function(it) { + if (!_isObject(it)) { + throw TypeError(it + " is not an object!"); + } + return it; + }; + var _fails = function(exec) { + try { + return !!exec(); + } catch (e) { + return true; + } + }; + var _descriptors = !_fails(function() { + return Object.defineProperty({}, "a", { get: function() { + return 7; + } }).a != 7; + }); + var document2 = _global.document; + var is = _isObject(document2) && _isObject(document2.createElement); + var _domCreate = function(it) { + return is ? document2.createElement(it) : {}; + }; + var _ie8DomDefine = !_descriptors && !_fails(function() { + return Object.defineProperty(_domCreate("div"), "a", { get: function() { + return 7; + } }).a != 7; + }); + var _toPrimitive = function(it, S) { + if (!_isObject(it)) { + return it; + } + var fn, val; + if (S && typeof (fn = it.toString) == "function" && !_isObject(val = fn.call(it))) { + return val; + } + if (typeof (fn = it.valueOf) == "function" && !_isObject(val = fn.call(it))) { + return val; + } + if (!S && typeof (fn = it.toString) == "function" && !_isObject(val = fn.call(it))) { + return val; + } + throw TypeError("Can't convert object to primitive value"); + }; + var dP = Object.defineProperty; + var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) { + _anObject(O); + P = _toPrimitive(P, true); + _anObject(Attributes); + if (_ie8DomDefine) { + try { + return dP(O, P, Attributes); + } catch (e) { + } + } + if ("get" in Attributes || "set" in Attributes) { + throw TypeError("Accessors not supported!"); + } + if ("value" in Attributes) { + O[P] = Attributes.value; + } + return O; + }; + var _objectDp = { + f + }; + var _propertyDesc = function(bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value + }; + }; + var _hide = _descriptors ? function(object, key2, value) { + return _objectDp.f(object, key2, _propertyDesc(1, value)); + } : function(object, key2, value) { + object[key2] = value; + return object; + }; + var hasOwnProperty = {}.hasOwnProperty; + var _has = function(it, key2) { + return hasOwnProperty.call(it, key2); + }; + var id = 0; + var px = Math.random(); + var _uid = function(key2) { + return "Symbol(".concat(key2 === void 0 ? "" : key2, ")_", (++id + px).toString(36)); + }; + var _library = false; + var _shared = createCommonjsModule(function(module3) { + var SHARED = "__core-js_shared__"; + var store = _global[SHARED] || (_global[SHARED] = {}); + (module3.exports = function(key2, value) { + return store[key2] || (store[key2] = value !== void 0 ? value : {}); + })("versions", []).push({ + version: _core.version, + mode: _library ? "pure" : "global", + copyright: "\xA9 2019 Denis Pushkarev (zloirock.ru)" + }); + }); + var _functionToString = _shared("native-function-to-string", Function.toString); + var _redefine = createCommonjsModule(function(module3) { + var SRC = _uid("src"); + var TO_STRING = "toString"; + var TPL = ("" + _functionToString).split(TO_STRING); + _core.inspectSource = function(it) { + return _functionToString.call(it); + }; + (module3.exports = function(O, key2, val, safe) { + var isFunction = typeof val == "function"; + if (isFunction) { + _has(val, "name") || _hide(val, "name", key2); + } + if (O[key2] === val) { + return; + } + if (isFunction) { + _has(val, SRC) || _hide(val, SRC, O[key2] ? "" + O[key2] : TPL.join(String(key2))); + } + if (O === _global) { + O[key2] = val; + } else if (!safe) { + delete O[key2]; + _hide(O, key2, val); + } else if (O[key2]) { + O[key2] = val; + } else { + _hide(O, key2, val); + } + })(Function.prototype, TO_STRING, function toString() { + return typeof this == "function" && this[SRC] || _functionToString.call(this); + }); + }); + var _aFunction = function(it) { + if (typeof it != "function") { + throw TypeError(it + " is not a function!"); + } + return it; + }; + var _ctx = function(fn, that, length) { + _aFunction(fn); + if (that === void 0) { + return fn; + } + switch (length) { + case 1: + return function(a) { + return fn.call(that, a); + }; + case 2: + return function(a, b) { + return fn.call(that, a, b); + }; + case 3: + return function(a, b, c2) { + return fn.call(that, a, b, c2); + }; + } + return function() { + return fn.apply(that, arguments); + }; + }; + var PROTOTYPE = "prototype"; + var $export = function(type, name, source2) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE]; + var exports2 = IS_GLOBAL ? _core : _core[name] || (_core[name] = {}); + var expProto = exports2[PROTOTYPE] || (exports2[PROTOTYPE] = {}); + var key2, own, out, exp; + if (IS_GLOBAL) { + source2 = name; + } + for (key2 in source2) { + own = !IS_FORCED && target && target[key2] !== void 0; + out = (own ? target : source2)[key2]; + exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == "function" ? _ctx(Function.call, out) : out; + if (target) { + _redefine(target, key2, out, type & $export.U); + } + if (exports2[key2] != out) { + _hide(exports2, key2, exp); + } + if (IS_PROTO && expProto[key2] != out) { + expProto[key2] = out; + } + } + }; + _global.core = _core; + $export.F = 1; + $export.G = 2; + $export.S = 4; + $export.P = 8; + $export.B = 16; + $export.W = 32; + $export.U = 64; + $export.R = 128; + var _export = $export; + var ceil = Math.ceil; + var floor = Math.floor; + var _toInteger = function(it) { + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); + }; + var _defined = function(it) { + if (it == void 0) { + throw TypeError("Can't call method on " + it); + } + return it; + }; + var _stringAt = function(TO_STRING) { + return function(that, pos2) { + var s = String(_defined(that)); + var i2 = _toInteger(pos2); + var l = s.length; + var a, b; + if (i2 < 0 || i2 >= l) { + return TO_STRING ? "" : void 0; + } + a = s.charCodeAt(i2); + return a < 55296 || a > 56319 || i2 + 1 === l || (b = s.charCodeAt(i2 + 1)) < 56320 || b > 57343 ? TO_STRING ? s.charAt(i2) : a : TO_STRING ? s.slice(i2, i2 + 2) : (a - 55296 << 10) + (b - 56320) + 65536; + }; + }; + var $at = _stringAt(false); + _export(_export.P, "String", { + codePointAt: function codePointAt2(pos2) { + return $at(this, pos2); + } + }); + var codePointAt = _core.String.codePointAt; + var max = Math.max; + var min = Math.min; + var _toAbsoluteIndex = function(index, length) { + index = _toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }; + var fromCharCode = String.fromCharCode; + var $fromCodePoint = String.fromCodePoint; + _export(_export.S + _export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), "String", { + fromCodePoint: function fromCodePoint2(x) { + var arguments$1 = arguments; + var res = []; + var aLen = arguments.length; + var i2 = 0; + var code; + while (aLen > i2) { + code = +arguments$1[i2++]; + if (_toAbsoluteIndex(code, 1114111) !== code) { + throw RangeError(code + " is not a valid code point"); + } + res.push( + code < 65536 ? fromCharCode(code) : fromCharCode(((code -= 65536) >> 10) + 55296, code % 1024 + 56320) + ); + } + return res.join(""); + } + }); + var fromCodePoint = _core.String.fromCodePoint; + var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/; + var ID_Start = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/; + var ID_Continue = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/; + var unicode = { + Space_Separator, + ID_Start, + ID_Continue + }; + var util = { + isSpaceSeparator: function isSpaceSeparator(c2) { + return typeof c2 === "string" && unicode.Space_Separator.test(c2); + }, + isIdStartChar: function isIdStartChar(c2) { + return typeof c2 === "string" && (c2 >= "a" && c2 <= "z" || c2 >= "A" && c2 <= "Z" || c2 === "$" || c2 === "_" || unicode.ID_Start.test(c2)); + }, + isIdContinueChar: function isIdContinueChar(c2) { + return typeof c2 === "string" && (c2 >= "a" && c2 <= "z" || c2 >= "A" && c2 <= "Z" || c2 >= "0" && c2 <= "9" || c2 === "$" || c2 === "_" || c2 === "\u200C" || c2 === "\u200D" || unicode.ID_Continue.test(c2)); + }, + isDigit: function isDigit(c2) { + return typeof c2 === "string" && /[0-9]/.test(c2); + }, + isHexDigit: function isHexDigit(c2) { + return typeof c2 === "string" && /[0-9A-Fa-f]/.test(c2); + } + }; + var source; + var parseState; + var stack; + var pos; + var line; + var column; + var token; + var key; + var root; + var parse2 = function parse3(text, reviver) { + source = String(text); + parseState = "start"; + stack = []; + pos = 0; + line = 1; + column = 0; + token = void 0; + key = void 0; + root = void 0; + do { + token = lex(); + parseStates[parseState](); + } while (token.type !== "eof"); + if (typeof reviver === "function") { + return internalize({ "": root }, "", reviver); + } + return root; + }; + function internalize(holder, name, reviver) { + var value = holder[name]; + if (value != null && typeof value === "object") { + if (Array.isArray(value)) { + for (var i2 = 0; i2 < value.length; i2++) { + var key2 = String(i2); + var replacement = internalize(value, key2, reviver); + if (replacement === void 0) { + delete value[key2]; + } else { + Object.defineProperty(value, key2, { + value: replacement, + writable: true, + enumerable: true, + configurable: true + }); + } + } + } else { + for (var key$1 in value) { + var replacement$1 = internalize(value, key$1, reviver); + if (replacement$1 === void 0) { + delete value[key$1]; + } else { + Object.defineProperty(value, key$1, { + value: replacement$1, + writable: true, + enumerable: true, + configurable: true + }); + } + } + } + } + return reviver.call(holder, name, value); + } + var lexState; + var buffer; + var doubleQuote; + var sign; + var c; + function lex() { + lexState = "default"; + buffer = ""; + doubleQuote = false; + sign = 1; + for (; ; ) { + c = peek(); + var token2 = lexStates[lexState](); + if (token2) { + return token2; + } + } + } + function peek() { + if (source[pos]) { + return String.fromCodePoint(source.codePointAt(pos)); + } + } + function read() { + var c2 = peek(); + if (c2 === "\n") { + line++; + column = 0; + } else if (c2) { + column += c2.length; + } else { + column++; + } + if (c2) { + pos += c2.length; + } + return c2; + } + var lexStates = { + default: function default$1() { + switch (c) { + case " ": + case "\v": + case "\f": + case " ": + case "\xA0": + case "\uFEFF": + case "\n": + case "\r": + case "\u2028": + case "\u2029": + read(); + return; + case "/": + read(); + lexState = "comment"; + return; + case void 0: + read(); + return newToken("eof"); + } + if (util.isSpaceSeparator(c)) { + read(); + return; + } + return lexStates[parseState](); + }, + comment: function comment() { + switch (c) { + case "*": + read(); + lexState = "multiLineComment"; + return; + case "/": + read(); + lexState = "singleLineComment"; + return; + } + throw invalidChar(read()); + }, + multiLineComment: function multiLineComment() { + switch (c) { + case "*": + read(); + lexState = "multiLineCommentAsterisk"; + return; + case void 0: + throw invalidChar(read()); + } + read(); + }, + multiLineCommentAsterisk: function multiLineCommentAsterisk() { + switch (c) { + case "*": + read(); + return; + case "/": + read(); + lexState = "default"; + return; + case void 0: + throw invalidChar(read()); + } + read(); + lexState = "multiLineComment"; + }, + singleLineComment: function singleLineComment() { + switch (c) { + case "\n": + case "\r": + case "\u2028": + case "\u2029": + read(); + lexState = "default"; + return; + case void 0: + read(); + return newToken("eof"); + } + read(); + }, + value: function value() { + switch (c) { + case "{": + case "[": + return newToken("punctuator", read()); + case "n": + read(); + literal("ull"); + return newToken("null", null); + case "t": + read(); + literal("rue"); + return newToken("boolean", true); + case "f": + read(); + literal("alse"); + return newToken("boolean", false); + case "-": + case "+": + if (read() === "-") { + sign = -1; + } + lexState = "sign"; + return; + case ".": + buffer = read(); + lexState = "decimalPointLeading"; + return; + case "0": + buffer = read(); + lexState = "zero"; + return; + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + buffer = read(); + lexState = "decimalInteger"; + return; + case "I": + read(); + literal("nfinity"); + return newToken("numeric", Infinity); + case "N": + read(); + literal("aN"); + return newToken("numeric", NaN); + case '"': + case "'": + doubleQuote = read() === '"'; + buffer = ""; + lexState = "string"; + return; + } + throw invalidChar(read()); + }, + identifierNameStartEscape: function identifierNameStartEscape() { + if (c !== "u") { + throw invalidChar(read()); + } + read(); + var u = unicodeEscape(); + switch (u) { + case "$": + case "_": + break; + default: + if (!util.isIdStartChar(u)) { + throw invalidIdentifier(); + } + break; + } + buffer += u; + lexState = "identifierName"; + }, + identifierName: function identifierName() { + switch (c) { + case "$": + case "_": + case "\u200C": + case "\u200D": + buffer += read(); + return; + case "\\": + read(); + lexState = "identifierNameEscape"; + return; + } + if (util.isIdContinueChar(c)) { + buffer += read(); + return; + } + return newToken("identifier", buffer); + }, + identifierNameEscape: function identifierNameEscape() { + if (c !== "u") { + throw invalidChar(read()); + } + read(); + var u = unicodeEscape(); + switch (u) { + case "$": + case "_": + case "\u200C": + case "\u200D": + break; + default: + if (!util.isIdContinueChar(u)) { + throw invalidIdentifier(); + } + break; + } + buffer += u; + lexState = "identifierName"; + }, + sign: function sign$1() { + switch (c) { + case ".": + buffer = read(); + lexState = "decimalPointLeading"; + return; + case "0": + buffer = read(); + lexState = "zero"; + return; + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + buffer = read(); + lexState = "decimalInteger"; + return; + case "I": + read(); + literal("nfinity"); + return newToken("numeric", sign * Infinity); + case "N": + read(); + literal("aN"); + return newToken("numeric", NaN); + } + throw invalidChar(read()); + }, + zero: function zero() { + switch (c) { + case ".": + buffer += read(); + lexState = "decimalPoint"; + return; + case "e": + case "E": + buffer += read(); + lexState = "decimalExponent"; + return; + case "x": + case "X": + buffer += read(); + lexState = "hexadecimal"; + return; + } + return newToken("numeric", sign * 0); + }, + decimalInteger: function decimalInteger() { + switch (c) { + case ".": + buffer += read(); + lexState = "decimalPoint"; + return; + case "e": + case "E": + buffer += read(); + lexState = "decimalExponent"; + return; + } + if (util.isDigit(c)) { + buffer += read(); + return; + } + return newToken("numeric", sign * Number(buffer)); + }, + decimalPointLeading: function decimalPointLeading() { + if (util.isDigit(c)) { + buffer += read(); + lexState = "decimalFraction"; + return; + } + throw invalidChar(read()); + }, + decimalPoint: function decimalPoint() { + switch (c) { + case "e": + case "E": + buffer += read(); + lexState = "decimalExponent"; + return; + } + if (util.isDigit(c)) { + buffer += read(); + lexState = "decimalFraction"; + return; + } + return newToken("numeric", sign * Number(buffer)); + }, + decimalFraction: function decimalFraction() { + switch (c) { + case "e": + case "E": + buffer += read(); + lexState = "decimalExponent"; + return; + } + if (util.isDigit(c)) { + buffer += read(); + return; + } + return newToken("numeric", sign * Number(buffer)); + }, + decimalExponent: function decimalExponent() { + switch (c) { + case "+": + case "-": + buffer += read(); + lexState = "decimalExponentSign"; + return; + } + if (util.isDigit(c)) { + buffer += read(); + lexState = "decimalExponentInteger"; + return; + } + throw invalidChar(read()); + }, + decimalExponentSign: function decimalExponentSign() { + if (util.isDigit(c)) { + buffer += read(); + lexState = "decimalExponentInteger"; + return; + } + throw invalidChar(read()); + }, + decimalExponentInteger: function decimalExponentInteger() { + if (util.isDigit(c)) { + buffer += read(); + return; + } + return newToken("numeric", sign * Number(buffer)); + }, + hexadecimal: function hexadecimal() { + if (util.isHexDigit(c)) { + buffer += read(); + lexState = "hexadecimalInteger"; + return; + } + throw invalidChar(read()); + }, + hexadecimalInteger: function hexadecimalInteger() { + if (util.isHexDigit(c)) { + buffer += read(); + return; + } + return newToken("numeric", sign * Number(buffer)); + }, + string: function string() { + switch (c) { + case "\\": + read(); + buffer += escape(); + return; + case '"': + if (doubleQuote) { + read(); + return newToken("string", buffer); + } + buffer += read(); + return; + case "'": + if (!doubleQuote) { + read(); + return newToken("string", buffer); + } + buffer += read(); + return; + case "\n": + case "\r": + throw invalidChar(read()); + case "\u2028": + case "\u2029": + separatorChar(c); + break; + case void 0: + throw invalidChar(read()); + } + buffer += read(); + }, + start: function start() { + switch (c) { + case "{": + case "[": + return newToken("punctuator", read()); + } + lexState = "value"; + }, + beforePropertyName: function beforePropertyName() { + switch (c) { + case "$": + case "_": + buffer = read(); + lexState = "identifierName"; + return; + case "\\": + read(); + lexState = "identifierNameStartEscape"; + return; + case "}": + return newToken("punctuator", read()); + case '"': + case "'": + doubleQuote = read() === '"'; + lexState = "string"; + return; + } + if (util.isIdStartChar(c)) { + buffer += read(); + lexState = "identifierName"; + return; + } + throw invalidChar(read()); + }, + afterPropertyName: function afterPropertyName() { + if (c === ":") { + return newToken("punctuator", read()); + } + throw invalidChar(read()); + }, + beforePropertyValue: function beforePropertyValue() { + lexState = "value"; + }, + afterPropertyValue: function afterPropertyValue() { + switch (c) { + case ",": + case "}": + return newToken("punctuator", read()); + } + throw invalidChar(read()); + }, + beforeArrayValue: function beforeArrayValue() { + if (c === "]") { + return newToken("punctuator", read()); + } + lexState = "value"; + }, + afterArrayValue: function afterArrayValue() { + switch (c) { + case ",": + case "]": + return newToken("punctuator", read()); + } + throw invalidChar(read()); + }, + end: function end() { + throw invalidChar(read()); + } + }; + function newToken(type, value) { + return { + type, + value, + line, + column + }; + } + function literal(s) { + for (var i2 = 0, list = s; i2 < list.length; i2 += 1) { + var c2 = list[i2]; + var p = peek(); + if (p !== c2) { + throw invalidChar(read()); + } + read(); + } + } + function escape() { + var c2 = peek(); + switch (c2) { + case "b": + read(); + return "\b"; + case "f": + read(); + return "\f"; + case "n": + read(); + return "\n"; + case "r": + read(); + return "\r"; + case "t": + read(); + return " "; + case "v": + read(); + return "\v"; + case "0": + read(); + if (util.isDigit(peek())) { + throw invalidChar(read()); + } + return "\0"; + case "x": + read(); + return hexEscape(); + case "u": + read(); + return unicodeEscape(); + case "\n": + case "\u2028": + case "\u2029": + read(); + return ""; + case "\r": + read(); + if (peek() === "\n") { + read(); + } + return ""; + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + throw invalidChar(read()); + case void 0: + throw invalidChar(read()); + } + return read(); + } + function hexEscape() { + var buffer2 = ""; + var c2 = peek(); + if (!util.isHexDigit(c2)) { + throw invalidChar(read()); + } + buffer2 += read(); + c2 = peek(); + if (!util.isHexDigit(c2)) { + throw invalidChar(read()); + } + buffer2 += read(); + return String.fromCodePoint(parseInt(buffer2, 16)); + } + function unicodeEscape() { + var buffer2 = ""; + var count = 4; + while (count-- > 0) { + var c2 = peek(); + if (!util.isHexDigit(c2)) { + throw invalidChar(read()); + } + buffer2 += read(); + } + return String.fromCodePoint(parseInt(buffer2, 16)); + } + var parseStates = { + start: function start() { + if (token.type === "eof") { + throw invalidEOF(); + } + push(); + }, + beforePropertyName: function beforePropertyName() { + switch (token.type) { + case "identifier": + case "string": + key = token.value; + parseState = "afterPropertyName"; + return; + case "punctuator": + pop(); + return; + case "eof": + throw invalidEOF(); + } + }, + afterPropertyName: function afterPropertyName() { + if (token.type === "eof") { + throw invalidEOF(); + } + parseState = "beforePropertyValue"; + }, + beforePropertyValue: function beforePropertyValue() { + if (token.type === "eof") { + throw invalidEOF(); + } + push(); + }, + beforeArrayValue: function beforeArrayValue() { + if (token.type === "eof") { + throw invalidEOF(); + } + if (token.type === "punctuator" && token.value === "]") { + pop(); + return; + } + push(); + }, + afterPropertyValue: function afterPropertyValue() { + if (token.type === "eof") { + throw invalidEOF(); + } + switch (token.value) { + case ",": + parseState = "beforePropertyName"; + return; + case "}": + pop(); + } + }, + afterArrayValue: function afterArrayValue() { + if (token.type === "eof") { + throw invalidEOF(); + } + switch (token.value) { + case ",": + parseState = "beforeArrayValue"; + return; + case "]": + pop(); + } + }, + end: function end() { + } + }; + function push() { + var value; + switch (token.type) { + case "punctuator": + switch (token.value) { + case "{": + value = {}; + break; + case "[": + value = []; + break; + } + break; + case "null": + case "boolean": + case "numeric": + case "string": + value = token.value; + break; + } + if (root === void 0) { + root = value; + } else { + var parent = stack[stack.length - 1]; + if (Array.isArray(parent)) { + parent.push(value); + } else { + Object.defineProperty(parent, key, { + value, + writable: true, + enumerable: true, + configurable: true + }); + } + } + if (value !== null && typeof value === "object") { + stack.push(value); + if (Array.isArray(value)) { + parseState = "beforeArrayValue"; + } else { + parseState = "beforePropertyName"; + } + } else { + var current = stack[stack.length - 1]; + if (current == null) { + parseState = "end"; + } else if (Array.isArray(current)) { + parseState = "afterArrayValue"; + } else { + parseState = "afterPropertyValue"; + } + } + } + function pop() { + stack.pop(); + var current = stack[stack.length - 1]; + if (current == null) { + parseState = "end"; + } else if (Array.isArray(current)) { + parseState = "afterArrayValue"; + } else { + parseState = "afterPropertyValue"; + } + } + function invalidChar(c2) { + if (c2 === void 0) { + return syntaxError("JSON5: invalid end of input at " + line + ":" + column); + } + return syntaxError("JSON5: invalid character '" + formatChar(c2) + "' at " + line + ":" + column); + } + function invalidEOF() { + return syntaxError("JSON5: invalid end of input at " + line + ":" + column); + } + function invalidIdentifier() { + column -= 5; + return syntaxError("JSON5: invalid identifier character at " + line + ":" + column); + } + function separatorChar(c2) { + console.warn("JSON5: '" + formatChar(c2) + "' in strings is not valid ECMAScript; consider escaping"); + } + function formatChar(c2) { + var replacements = { + "'": "\\'", + '"': '\\"', + "\\": "\\\\", + "\b": "\\b", + "\f": "\\f", + "\n": "\\n", + "\r": "\\r", + " ": "\\t", + "\v": "\\v", + "\0": "\\0", + "\u2028": "\\u2028", + "\u2029": "\\u2029" + }; + if (replacements[c2]) { + return replacements[c2]; + } + if (c2 < " ") { + var hexString = c2.charCodeAt(0).toString(16); + return "\\x" + ("00" + hexString).substring(hexString.length); + } + return c2; + } + function syntaxError(message) { + var err = new SyntaxError(message); + err.lineNumber = line; + err.columnNumber = column; + return err; + } + var stringify = function stringify2(value, replacer, space) { + var stack2 = []; + var indent = ""; + var propertyList; + var replacerFunc; + var gap = ""; + var quote; + if (replacer != null && typeof replacer === "object" && !Array.isArray(replacer)) { + space = replacer.space; + quote = replacer.quote; + replacer = replacer.replacer; + } + if (typeof replacer === "function") { + replacerFunc = replacer; + } else if (Array.isArray(replacer)) { + propertyList = []; + for (var i2 = 0, list = replacer; i2 < list.length; i2 += 1) { + var v = list[i2]; + var item = void 0; + if (typeof v === "string") { + item = v; + } else if (typeof v === "number" || v instanceof String || v instanceof Number) { + item = String(v); + } + if (item !== void 0 && propertyList.indexOf(item) < 0) { + propertyList.push(item); + } + } + } + if (space instanceof Number) { + space = Number(space); + } else if (space instanceof String) { + space = String(space); + } + if (typeof space === "number") { + if (space > 0) { + space = Math.min(10, Math.floor(space)); + gap = " ".substr(0, space); + } + } else if (typeof space === "string") { + gap = space.substr(0, 10); + } + return serializeProperty("", { "": value }); + function serializeProperty(key2, holder) { + var value2 = holder[key2]; + if (value2 != null) { + if (typeof value2.toJSON5 === "function") { + value2 = value2.toJSON5(key2); + } else if (typeof value2.toJSON === "function") { + value2 = value2.toJSON(key2); + } + } + if (replacerFunc) { + value2 = replacerFunc.call(holder, key2, value2); + } + if (value2 instanceof Number) { + value2 = Number(value2); + } else if (value2 instanceof String) { + value2 = String(value2); + } else if (value2 instanceof Boolean) { + value2 = value2.valueOf(); + } + switch (value2) { + case null: + return "null"; + case true: + return "true"; + case false: + return "false"; + } + if (typeof value2 === "string") { + return quoteString(value2, false); + } + if (typeof value2 === "number") { + return String(value2); + } + if (typeof value2 === "object") { + return Array.isArray(value2) ? serializeArray(value2) : serializeObject(value2); + } + return void 0; + } + function quoteString(value2) { + var quotes = { + "'": 0.1, + '"': 0.2 + }; + var replacements = { + "'": "\\'", + '"': '\\"', + "\\": "\\\\", + "\b": "\\b", + "\f": "\\f", + "\n": "\\n", + "\r": "\\r", + " ": "\\t", + "\v": "\\v", + "\0": "\\0", + "\u2028": "\\u2028", + "\u2029": "\\u2029" + }; + var product = ""; + for (var i3 = 0; i3 < value2.length; i3++) { + var c2 = value2[i3]; + switch (c2) { + case "'": + case '"': + quotes[c2]++; + product += c2; + continue; + case "\0": + if (util.isDigit(value2[i3 + 1])) { + product += "\\x00"; + continue; + } + } + if (replacements[c2]) { + product += replacements[c2]; + continue; + } + if (c2 < " ") { + var hexString = c2.charCodeAt(0).toString(16); + product += "\\x" + ("00" + hexString).substring(hexString.length); + continue; + } + product += c2; + } + var quoteChar = quote || Object.keys(quotes).reduce(function(a, b) { + return quotes[a] < quotes[b] ? a : b; + }); + product = product.replace(new RegExp(quoteChar, "g"), replacements[quoteChar]); + return quoteChar + product + quoteChar; + } + function serializeObject(value2) { + if (stack2.indexOf(value2) >= 0) { + throw TypeError("Converting circular structure to JSON5"); + } + stack2.push(value2); + var stepback = indent; + indent = indent + gap; + var keys = propertyList || Object.keys(value2); + var partial = []; + for (var i3 = 0, list2 = keys; i3 < list2.length; i3 += 1) { + var key2 = list2[i3]; + var propertyString = serializeProperty(key2, value2); + if (propertyString !== void 0) { + var member = serializeKey(key2) + ":"; + if (gap !== "") { + member += " "; + } + member += propertyString; + partial.push(member); + } + } + var final; + if (partial.length === 0) { + final = "{}"; + } else { + var properties; + if (gap === "") { + properties = partial.join(","); + final = "{" + properties + "}"; + } else { + var separator = ",\n" + indent; + properties = partial.join(separator); + final = "{\n" + indent + properties + ",\n" + stepback + "}"; + } + } + stack2.pop(); + indent = stepback; + return final; + } + function serializeKey(key2) { + if (key2.length === 0) { + return quoteString(key2, true); + } + var firstChar = String.fromCodePoint(key2.codePointAt(0)); + if (!util.isIdStartChar(firstChar)) { + return quoteString(key2, true); + } + for (var i3 = firstChar.length; i3 < key2.length; i3++) { + if (!util.isIdContinueChar(String.fromCodePoint(key2.codePointAt(i3)))) { + return quoteString(key2, true); + } + } + return key2; + } + function serializeArray(value2) { + if (stack2.indexOf(value2) >= 0) { + throw TypeError("Converting circular structure to JSON5"); + } + stack2.push(value2); + var stepback = indent; + indent = indent + gap; + var partial = []; + for (var i3 = 0; i3 < value2.length; i3++) { + var propertyString = serializeProperty(String(i3), value2); + partial.push(propertyString !== void 0 ? propertyString : "null"); + } + var final; + if (partial.length === 0) { + final = "[]"; + } else { + if (gap === "") { + var properties = partial.join(","); + final = "[" + properties + "]"; + } else { + var separator = ",\n" + indent; + var properties$1 = partial.join(separator); + final = "[\n" + indent + properties$1 + ",\n" + stepback + "]"; + } + } + stack2.pop(); + indent = stepback; + return final; + } + }; + var JSON52 = { + parse: parse2, + stringify + }; + var lib = JSON52; + var es5 = lib; + return es5; + }); + } +}); + +// node_modules/readline-sync/lib/readline-sync.js +var require_readline_sync = __commonJS({ + "node_modules/readline-sync/lib/readline-sync.js"(exports) { + "use strict"; + var IS_WIN = process.platform === "win32"; + var ALGORITHM_CIPHER = "aes-256-cbc"; + var ALGORITHM_HASH = "sha256"; + var DEFAULT_ERR_MSG = "The current environment doesn't support interactive reading from TTY."; + var fs2 = require("fs"); + var TTY = process.binding("tty_wrap").TTY; + var childProc = require("child_process"); + var pathUtil = require("path"); + var defaultOptions = { + prompt: "> ", + hideEchoBack: false, + mask: "*", + limit: [], + limitMessage: "Input another, please.$<( [)limit(])>", + defaultInput: "", + trueValue: [], + falseValue: [], + caseSensitive: false, + keepWhitespace: false, + encoding: "utf8", + bufferSize: 1024, + print: void 0, + history: true, + cd: false, + phContent: void 0, + preCheck: void 0 + }; + var fdR = "none"; + var fdW; + var ttyR; + var isRawMode = false; + var extHostPath; + var extHostArgs; + var tempdir; + var salt = 0; + var lastInput = ""; + var inputHistory = []; + var rawInput; + var _DBG_useExt = false; + var _DBG_checkOptions = false; + var _DBG_checkMethod = false; + function getHostArgs(options) { + function encodeArg(arg) { + return arg.replace(/[^\w\u0080-\uFFFF]/g, function(chr) { + return "#" + chr.charCodeAt(0) + ";"; + }); + } + return extHostArgs.concat(function(conf) { + var args = []; + Object.keys(conf).forEach(function(optionName) { + if (conf[optionName] === "boolean") { + if (options[optionName]) { + args.push("--" + optionName); + } + } else if (conf[optionName] === "string") { + if (options[optionName]) { + args.push("--" + optionName, encodeArg(options[optionName])); + } + } + }); + return args; + }({ + display: "string", + displayOnly: "boolean", + keyIn: "boolean", + hideEchoBack: "boolean", + mask: "string", + limit: "string", + caseSensitive: "boolean" + })); + } + function _execFileSync(options, execOptions) { + function getTempfile(name) { + var filepath, suffix = "", fd; + tempdir = tempdir || require("os").tmpdir(); + while (true) { + filepath = pathUtil.join(tempdir, name + suffix); + try { + fd = fs2.openSync(filepath, "wx"); + } catch (e) { + if (e.code === "EEXIST") { + suffix++; + continue; + } else { + throw e; + } + } + fs2.closeSync(fd); + break; + } + return filepath; + } + var hostArgs, shellPath, shellArgs, res = {}, exitCode, extMessage, pathStdout = getTempfile("readline-sync.stdout"), pathStderr = getTempfile("readline-sync.stderr"), pathExit = getTempfile("readline-sync.exit"), pathDone = getTempfile("readline-sync.done"), crypto = require("crypto"), shasum, decipher, password; + shasum = crypto.createHash(ALGORITHM_HASH); + shasum.update("" + process.pid + salt++ + Math.random()); + password = shasum.digest("hex"); + decipher = crypto.createDecipher(ALGORITHM_CIPHER, password); + hostArgs = getHostArgs(options); + if (IS_WIN) { + shellPath = process.env.ComSpec || "cmd.exe"; + process.env.Q = '"'; + shellArgs = [ + "/V:ON", + "/S", + "/C", + "(%Q%" + shellPath + "%Q% /V:ON /S /C %Q%%Q%" + extHostPath + "%Q%" + hostArgs.map(function(arg) { + return " %Q%" + arg + "%Q%"; + }).join("") + " & (echo !ERRORLEVEL!)>%Q%" + pathExit + "%Q%%Q%) 2>%Q%" + pathStderr + "%Q% |%Q%" + process.execPath + "%Q% %Q%" + __dirname + "\\encrypt.js%Q% %Q%" + ALGORITHM_CIPHER + "%Q% %Q%" + password + "%Q% >%Q%" + pathStdout + "%Q% & (echo 1)>%Q%" + pathDone + "%Q%" + ]; + } else { + shellPath = "/bin/sh"; + shellArgs = [ + "-c", + '("' + extHostPath + '"' + hostArgs.map(function(arg) { + return " '" + arg.replace(/'/g, "'\\''") + "'"; + }).join("") + '; echo $?>"' + pathExit + '") 2>"' + pathStderr + '" |"' + process.execPath + '" "' + __dirname + '/encrypt.js" "' + ALGORITHM_CIPHER + '" "' + password + '" >"' + pathStdout + '"; echo 1 >"' + pathDone + '"' + ]; + } + if (_DBG_checkMethod) { + _DBG_checkMethod("_execFileSync", hostArgs); + } + try { + childProc.spawn(shellPath, shellArgs, execOptions); + } catch (e) { + res.error = new Error(e.message); + res.error.method = "_execFileSync - spawn"; + res.error.program = shellPath; + res.error.args = shellArgs; + } + while (fs2.readFileSync(pathDone, { encoding: options.encoding }).trim() !== "1") { + } + if ((exitCode = fs2.readFileSync(pathExit, { encoding: options.encoding }).trim()) === "0") { + res.input = decipher.update( + fs2.readFileSync(pathStdout, { encoding: "binary" }), + "hex", + options.encoding + ) + decipher.final(options.encoding); + } else { + extMessage = fs2.readFileSync(pathStderr, { encoding: options.encoding }).trim(); + res.error = new Error(DEFAULT_ERR_MSG + (extMessage ? "\n" + extMessage : "")); + res.error.method = "_execFileSync"; + res.error.program = shellPath; + res.error.args = shellArgs; + res.error.extMessage = extMessage; + res.error.exitCode = +exitCode; + } + fs2.unlinkSync(pathStdout); + fs2.unlinkSync(pathStderr); + fs2.unlinkSync(pathExit); + fs2.unlinkSync(pathDone); + return res; + } + function readlineExt(options) { + var hostArgs, res = {}, extMessage, execOptions = { env: process.env, encoding: options.encoding }; + if (!extHostPath) { + if (IS_WIN) { + if (process.env.PSModulePath) { + extHostPath = "powershell.exe"; + extHostArgs = ["-ExecutionPolicy", "Bypass", "-File", __dirname + "\\read.ps1"]; + } else { + extHostPath = "cscript.exe"; + extHostArgs = ["//nologo", __dirname + "\\read.cs.js"]; + } + } else { + extHostPath = "/bin/sh"; + extHostArgs = [__dirname + "/read.sh"]; + } + } + if (IS_WIN && !process.env.PSModulePath) { + execOptions.stdio = [process.stdin]; + } + if (childProc.execFileSync) { + hostArgs = getHostArgs(options); + if (_DBG_checkMethod) { + _DBG_checkMethod("execFileSync", hostArgs); + } + try { + res.input = childProc.execFileSync(extHostPath, hostArgs, execOptions); + } catch (e) { + extMessage = e.stderr ? (e.stderr + "").trim() : ""; + res.error = new Error(DEFAULT_ERR_MSG + (extMessage ? "\n" + extMessage : "")); + res.error.method = "execFileSync"; + res.error.program = extHostPath; + res.error.args = hostArgs; + res.error.extMessage = extMessage; + res.error.exitCode = e.status; + res.error.code = e.code; + res.error.signal = e.signal; + } + } else { + res = _execFileSync(options, execOptions); + } + if (!res.error) { + res.input = res.input.replace(/^\s*'|'\s*$/g, ""); + options.display = ""; + } + return res; + } + function _readlineSync(options) { + var input = "", displaySave = options.display, silent = !options.display && options.keyIn && options.hideEchoBack && !options.mask; + function tryExt() { + var res = readlineExt(options); + if (res.error) { + throw res.error; + } + return res.input; + } + if (_DBG_checkOptions) { + _DBG_checkOptions(options); + } + (function() { + var fsB, constants, verNum; + function getFsB() { + if (!fsB) { + fsB = process.binding("fs"); + constants = process.binding("constants"); + } + return fsB; + } + if (typeof fdR !== "string") { + return; + } + fdR = null; + if (IS_WIN) { + verNum = function(ver) { + var nums = ver.replace(/^\D+/, "").split("."); + var verNum2 = 0; + if (nums[0] = +nums[0]) { + verNum2 += nums[0] * 1e4; + } + if (nums[1] = +nums[1]) { + verNum2 += nums[1] * 100; + } + if (nums[2] = +nums[2]) { + verNum2 += nums[2]; + } + return verNum2; + }(process.version); + if (!(verNum >= 20302 && verNum < 40204 || verNum >= 5e4 && verNum < 50100 || verNum >= 50600 && verNum < 60200) && process.stdin.isTTY) { + process.stdin.pause(); + fdR = process.stdin.fd; + ttyR = process.stdin._handle; + } else { + try { + fdR = getFsB().open("CONIN$", constants.O_RDWR, parseInt("0666", 8)); + ttyR = new TTY(fdR, true); + } catch (e) { + } + } + if (process.stdout.isTTY) { + fdW = process.stdout.fd; + } else { + try { + fdW = fs2.openSync("\\\\.\\CON", "w"); + } catch (e) { + } + if (typeof fdW !== "number") { + try { + fdW = getFsB().open("CONOUT$", constants.O_RDWR, parseInt("0666", 8)); + } catch (e) { + } + } + } + } else { + if (process.stdin.isTTY) { + process.stdin.pause(); + try { + fdR = fs2.openSync("/dev/tty", "r"); + ttyR = process.stdin._handle; + } catch (e) { + } + } else { + try { + fdR = fs2.openSync("/dev/tty", "r"); + ttyR = new TTY(fdR, false); + } catch (e) { + } + } + if (process.stdout.isTTY) { + fdW = process.stdout.fd; + } else { + try { + fdW = fs2.openSync("/dev/tty", "w"); + } catch (e) { + } + } + } + })(); + (function() { + var atEol, limit, isCooked = !options.hideEchoBack && !options.keyIn, buffer, reqSize, readSize, chunk, line; + rawInput = ""; + function setRawMode(mode) { + if (mode === isRawMode) { + return true; + } + if (ttyR.setRawMode(mode) !== 0) { + return false; + } + isRawMode = mode; + return true; + } + if (_DBG_useExt || !ttyR || typeof fdW !== "number" && (options.display || !isCooked)) { + input = tryExt(); + return; + } + if (options.display) { + fs2.writeSync(fdW, options.display); + options.display = ""; + } + if (options.displayOnly) { + return; + } + if (!setRawMode(!isCooked)) { + input = tryExt(); + return; + } + reqSize = options.keyIn ? 1 : options.bufferSize; + buffer = Buffer.allocUnsafe && Buffer.alloc ? Buffer.alloc(reqSize) : new Buffer(reqSize); + if (options.keyIn && options.limit) { + limit = new RegExp( + "[^" + options.limit + "]", + "g" + (options.caseSensitive ? "" : "i") + ); + } + while (true) { + readSize = 0; + try { + readSize = fs2.readSync(fdR, buffer, 0, reqSize); + } catch (e) { + if (e.code !== "EOF") { + setRawMode(false); + input += tryExt(); + return; + } + } + if (readSize > 0) { + chunk = buffer.toString(options.encoding, 0, readSize); + rawInput += chunk; + } else { + chunk = "\n"; + rawInput += String.fromCharCode(0); + } + if (chunk && typeof (line = (chunk.match(/^(.*?)[\r\n]/) || [])[1]) === "string") { + chunk = line; + atEol = true; + } + if (chunk) { + chunk = chunk.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ""); + } + if (chunk && limit) { + chunk = chunk.replace(limit, ""); + } + if (chunk) { + if (!isCooked) { + if (!options.hideEchoBack) { + fs2.writeSync(fdW, chunk); + } else if (options.mask) { + fs2.writeSync(fdW, new Array(chunk.length + 1).join(options.mask)); + } + } + input += chunk; + } + if (!options.keyIn && atEol || options.keyIn && input.length >= reqSize) { + break; + } + } + if (!isCooked && !silent) { + fs2.writeSync(fdW, "\n"); + } + setRawMode(false); + })(); + if (options.print && !silent) { + options.print( + displaySave + (options.displayOnly ? "" : (options.hideEchoBack ? new Array(input.length + 1).join(options.mask) : input) + "\n"), + options.encoding + ); + } + return options.displayOnly ? "" : lastInput = options.keepWhitespace || options.keyIn ? input : input.trim(); + } + function flattenArray(array, validator) { + var flatArray = []; + function _flattenArray(array2) { + if (array2 == null) { + return; + } else if (Array.isArray(array2)) { + array2.forEach(_flattenArray); + } else if (!validator || validator(array2)) { + flatArray.push(array2); + } + } + _flattenArray(array); + return flatArray; + } + function escapePattern(pattern) { + return pattern.replace( + /[\x00-\x7f]/g, + function(s) { + return "\\x" + ("00" + s.charCodeAt().toString(16)).substr(-2); + } + ); + } + function margeOptions() { + var optionsList = Array.prototype.slice.call(arguments), optionNames, fromDefault; + if (optionsList.length && typeof optionsList[0] === "boolean") { + fromDefault = optionsList.shift(); + if (fromDefault) { + optionNames = Object.keys(defaultOptions); + optionsList.unshift(defaultOptions); + } + } + return optionsList.reduce(function(options, optionsPart) { + if (optionsPart == null) { + return options; + } + if (optionsPart.hasOwnProperty("noEchoBack") && !optionsPart.hasOwnProperty("hideEchoBack")) { + optionsPart.hideEchoBack = optionsPart.noEchoBack; + delete optionsPart.noEchoBack; + } + if (optionsPart.hasOwnProperty("noTrim") && !optionsPart.hasOwnProperty("keepWhitespace")) { + optionsPart.keepWhitespace = optionsPart.noTrim; + delete optionsPart.noTrim; + } + if (!fromDefault) { + optionNames = Object.keys(optionsPart); + } + optionNames.forEach(function(optionName) { + var value; + if (!optionsPart.hasOwnProperty(optionName)) { + return; + } + value = optionsPart[optionName]; + switch (optionName) { + case "mask": + case "limitMessage": + case "defaultInput": + case "encoding": + value = value != null ? value + "" : ""; + if (value && optionName !== "limitMessage") { + value = value.replace(/[\r\n]/g, ""); + } + options[optionName] = value; + break; + case "bufferSize": + if (!isNaN(value = parseInt(value, 10)) && typeof value === "number") { + options[optionName] = value; + } + break; + case "displayOnly": + case "keyIn": + case "hideEchoBack": + case "caseSensitive": + case "keepWhitespace": + case "history": + case "cd": + options[optionName] = !!value; + break; + case "limit": + case "trueValue": + case "falseValue": + options[optionName] = flattenArray(value, function(value2) { + var type = typeof value2; + return type === "string" || type === "number" || type === "function" || value2 instanceof RegExp; + }).map(function(value2) { + return typeof value2 === "string" ? value2.replace(/[\r\n]/g, "") : value2; + }); + break; + case "print": + case "phContent": + case "preCheck": + options[optionName] = typeof value === "function" ? value : void 0; + break; + case "prompt": + case "display": + options[optionName] = value != null ? value : ""; + break; + } + }); + return options; + }, {}); + } + function isMatched(res, comps, caseSensitive) { + return comps.some(function(comp) { + var type = typeof comp; + return type === "string" ? caseSensitive ? res === comp : res.toLowerCase() === comp.toLowerCase() : type === "number" ? parseFloat(res) === comp : type === "function" ? comp(res) : comp instanceof RegExp ? comp.test(res) : false; + }); + } + function replaceHomePath(path2, expand) { + var homePath = pathUtil.normalize( + IS_WIN ? (process.env.HOMEDRIVE || "") + (process.env.HOMEPATH || "") : process.env.HOME || "" + ).replace(/[\/\\]+$/, ""); + path2 = pathUtil.normalize(path2); + return expand ? path2.replace(/^~(?=\/|\\|$)/, homePath) : path2.replace(new RegExp("^" + escapePattern(homePath) + "(?=\\/|\\\\|$)", IS_WIN ? "i" : ""), "~"); + } + function replacePlaceholder(text, generator) { + var PTN_INNER = "(?:\\(([\\s\\S]*?)\\))?(\\w+|.-.)(?:\\(([\\s\\S]*?)\\))?", rePlaceholder = new RegExp("(\\$)?(\\$<" + PTN_INNER + ">)", "g"), rePlaceholderCompat = new RegExp("(\\$)?(\\$\\{" + PTN_INNER + "\\})", "g"); + function getPlaceholderText(s, escape, placeholder, pre, param, post) { + var text2; + return escape || typeof (text2 = generator(param)) !== "string" ? placeholder : text2 ? (pre || "") + text2 + (post || "") : ""; + } + return text.replace(rePlaceholder, getPlaceholderText).replace(rePlaceholderCompat, getPlaceholderText); + } + function array2charlist(array, caseSensitive, collectSymbols) { + var values, group2 = [], groupClass = -1, charCode = 0, symbols = "", suppressed; + function addGroup(groups, group3) { + if (group3.length > 3) { + groups.push(group3[0] + "..." + group3[group3.length - 1]); + suppressed = true; + } else if (group3.length) { + groups = groups.concat(group3); + } + return groups; + } + values = array.reduce( + function(chars, value) { + return chars.concat((value + "").split("")); + }, + [] + ).reduce(function(groups, curChar) { + var curGroupClass, curCharCode; + if (!caseSensitive) { + curChar = curChar.toLowerCase(); + } + curGroupClass = /^\d$/.test(curChar) ? 1 : /^[A-Z]$/.test(curChar) ? 2 : /^[a-z]$/.test(curChar) ? 3 : 0; + if (collectSymbols && curGroupClass === 0) { + symbols += curChar; + } else { + curCharCode = curChar.charCodeAt(0); + if (curGroupClass && curGroupClass === groupClass && curCharCode === charCode + 1) { + group2.push(curChar); + } else { + groups = addGroup(groups, group2); + group2 = [curChar]; + groupClass = curGroupClass; + } + charCode = curCharCode; + } + return groups; + }, []); + values = addGroup(values, group2); + if (symbols) { + values.push(symbols); + suppressed = true; + } + return { values, suppressed }; + } + function joinChunks(chunks, suppressed) { + return chunks.join(chunks.length > 2 ? ", " : suppressed ? " / " : "/"); + } + function getPhContent(param, options) { + var text, values, resCharlist = {}, arg; + if (options.phContent) { + text = options.phContent(param, options); + } + if (typeof text !== "string") { + switch (param) { + case "hideEchoBack": + case "mask": + case "defaultInput": + case "caseSensitive": + case "keepWhitespace": + case "encoding": + case "bufferSize": + case "history": + case "cd": + text = !options.hasOwnProperty(param) ? "" : typeof options[param] === "boolean" ? options[param] ? "on" : "off" : options[param] + ""; + break; + case "limit": + case "trueValue": + case "falseValue": + values = options[options.hasOwnProperty(param + "Src") ? param + "Src" : param]; + if (options.keyIn) { + resCharlist = array2charlist(values, options.caseSensitive); + values = resCharlist.values; + } else { + values = values.filter(function(value) { + var type = typeof value; + return type === "string" || type === "number"; + }); + } + text = joinChunks(values, resCharlist.suppressed); + break; + case "limitCount": + case "limitCountNotZero": + text = options[options.hasOwnProperty("limitSrc") ? "limitSrc" : "limit"].length; + text = text || param !== "limitCountNotZero" ? text + "" : ""; + break; + case "lastInput": + text = lastInput; + break; + case "cwd": + case "CWD": + case "cwdHome": + text = process.cwd(); + if (param === "CWD") { + text = pathUtil.basename(text); + } else if (param === "cwdHome") { + text = replaceHomePath(text); + } + break; + case "date": + case "time": + case "localeDate": + case "localeTime": + text = new Date()["to" + param.replace(/^./, function(str) { + return str.toUpperCase(); + }) + "String"](); + break; + default: + if (typeof (arg = (param.match(/^history_m(\d+)$/) || [])[1]) === "string") { + text = inputHistory[inputHistory.length - arg] || ""; + } + } + } + return text; + } + function getPhCharlist(param) { + var matches = /^(.)-(.)$/.exec(param), text = "", from, to, code, step; + if (!matches) { + return null; + } + from = matches[1].charCodeAt(0); + to = matches[2].charCodeAt(0); + step = from < to ? 1 : -1; + for (code = from; code !== to + step; code += step) { + text += String.fromCharCode(code); + } + return text; + } + function parseCl(cl) { + var reToken = new RegExp(/(\s*)(?:("|')(.*?)(?:\2|$)|(\S+))/g), matches, taken = "", args = [], part; + cl = cl.trim(); + while (matches = reToken.exec(cl)) { + part = matches[3] || matches[4] || ""; + if (matches[1]) { + args.push(taken); + taken = ""; + } + taken += part; + } + if (taken) { + args.push(taken); + } + return args; + } + function toBool(res, options) { + return options.trueValue.length && isMatched(res, options.trueValue, options.caseSensitive) ? true : options.falseValue.length && isMatched(res, options.falseValue, options.caseSensitive) ? false : res; + } + function getValidLine(options) { + var res, forceNext, limitMessage, matches, histInput, args, resCheck; + function _getPhContent(param) { + return getPhContent(param, options); + } + function addDisplay(text) { + options.display += (/[^\r\n]$/.test(options.display) ? "\n" : "") + text; + } + options.limitSrc = options.limit; + options.displaySrc = options.display; + options.limit = ""; + options.display = replacePlaceholder(options.display + "", _getPhContent); + while (true) { + res = _readlineSync(options); + forceNext = false; + limitMessage = ""; + if (options.defaultInput && !res) { + res = options.defaultInput; + } + if (options.history) { + if (matches = /^\s*\!(?:\!|-1)(:p)?\s*$/.exec(res)) { + histInput = inputHistory[0] || ""; + if (matches[1]) { + forceNext = true; + } else { + res = histInput; + } + addDisplay(histInput + "\n"); + if (!forceNext) { + options.displayOnly = true; + _readlineSync(options); + options.displayOnly = false; + } + } else if (res && res !== inputHistory[inputHistory.length - 1]) { + inputHistory = [res]; + } + } + if (!forceNext && options.cd && res) { + args = parseCl(res); + switch (args[0].toLowerCase()) { + case "cd": + if (args[1]) { + try { + process.chdir(replaceHomePath(args[1], true)); + } catch (e) { + addDisplay(e + ""); + } + } + forceNext = true; + break; + case "pwd": + addDisplay(process.cwd()); + forceNext = true; + break; + } + } + if (!forceNext && options.preCheck) { + resCheck = options.preCheck(res, options); + res = resCheck.res; + if (resCheck.forceNext) { + forceNext = true; + } + } + if (!forceNext) { + if (!options.limitSrc.length || isMatched(res, options.limitSrc, options.caseSensitive)) { + break; + } + if (options.limitMessage) { + limitMessage = replacePlaceholder(options.limitMessage, _getPhContent); + } + } + addDisplay((limitMessage ? limitMessage + "\n" : "") + replacePlaceholder(options.displaySrc + "", _getPhContent)); + } + return toBool(res, options); + } + exports._DBG_set_useExt = function(val) { + _DBG_useExt = val; + }; + exports._DBG_set_checkOptions = function(val) { + _DBG_checkOptions = val; + }; + exports._DBG_set_checkMethod = function(val) { + _DBG_checkMethod = val; + }; + exports._DBG_clearHistory = function() { + lastInput = ""; + inputHistory = []; + }; + exports.setDefaultOptions = function(options) { + defaultOptions = margeOptions(true, options); + return margeOptions(true); + }; + exports.question = function(query, options) { + return getValidLine(margeOptions(margeOptions(true, options), { + display: query + })); + }; + exports.prompt = function(options) { + var readOptions = margeOptions(true, options); + readOptions.display = readOptions.prompt; + return getValidLine(readOptions); + }; + exports.keyIn = function(query, options) { + var readOptions = margeOptions(margeOptions(true, options), { + display: query, + keyIn: true, + keepWhitespace: true + }); + readOptions.limitSrc = readOptions.limit.filter(function(value) { + var type = typeof value; + return type === "string" || type === "number"; + }).map(function(text) { + return replacePlaceholder(text + "", getPhCharlist); + }); + readOptions.limit = escapePattern(readOptions.limitSrc.join("")); + ["trueValue", "falseValue"].forEach(function(optionName) { + readOptions[optionName] = readOptions[optionName].reduce(function(comps, comp) { + var type = typeof comp; + if (type === "string" || type === "number") { + comps = comps.concat((comp + "").split("")); + } else { + comps.push(comp); + } + return comps; + }, []); + }); + readOptions.display = replacePlaceholder( + readOptions.display + "", + function(param) { + return getPhContent(param, readOptions); + } + ); + return toBool(_readlineSync(readOptions), readOptions); + }; + exports.questionEMail = function(query, options) { + if (query == null) { + query = "Input e-mail address: "; + } + return exports.question(query, margeOptions({ + hideEchoBack: false, + limit: /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, + limitMessage: "Input valid e-mail address, please.", + trueValue: null, + falseValue: null + }, options, { + keepWhitespace: false, + cd: false + })); + }; + exports.questionNewPassword = function(query, options) { + var resCharlist, min, max, readOptions = margeOptions({ + hideEchoBack: true, + mask: "*", + limitMessage: "It can include: $\nAnd the length must be: $", + trueValue: null, + falseValue: null, + caseSensitive: true + }, options, { + history: false, + cd: false, + phContent: function(param) { + return param === "charlist" ? resCharlist.text : param === "length" ? min + "..." + max : null; + } + }), charlist, confirmMessage, unmatchMessage, limit, limitMessage, res1, res2; + options = options || {}; + charlist = replacePlaceholder( + options.charlist ? options.charlist + "" : "$", + getPhCharlist + ); + if (isNaN(min = parseInt(options.min, 10)) || typeof min !== "number") { + min = 12; + } + if (isNaN(max = parseInt(options.max, 10)) || typeof max !== "number") { + max = 24; + } + limit = new RegExp("^[" + escapePattern(charlist) + "]{" + min + "," + max + "}$"); + resCharlist = array2charlist([charlist], readOptions.caseSensitive, true); + resCharlist.text = joinChunks(resCharlist.values, resCharlist.suppressed); + confirmMessage = options.confirmMessage != null ? options.confirmMessage : "Reinput a same one to confirm it: "; + unmatchMessage = options.unmatchMessage != null ? options.unmatchMessage : "It differs from first one. Hit only the Enter key if you want to retry from first one."; + if (query == null) { + query = "Input new password: "; + } + limitMessage = readOptions.limitMessage; + while (!res2) { + readOptions.limit = limit; + readOptions.limitMessage = limitMessage; + res1 = exports.question(query, readOptions); + readOptions.limit = [res1, ""]; + readOptions.limitMessage = unmatchMessage; + res2 = exports.question(confirmMessage, readOptions); + } + return res1; + }; + function _questionNum(query, options, parser) { + var validValue; + function getValidValue(value) { + validValue = parser(value); + return !isNaN(validValue) && typeof validValue === "number"; + } + exports.question(query, margeOptions({ + limitMessage: "Input valid number, please." + }, options, { + limit: getValidValue, + cd: false + })); + return validValue; + } + exports.questionInt = function(query, options) { + return _questionNum(query, options, function(value) { + return parseInt(value, 10); + }); + }; + exports.questionFloat = function(query, options) { + return _questionNum(query, options, parseFloat); + }; + exports.questionPath = function(query, options) { + var validPath, error = "", readOptions = margeOptions({ + hideEchoBack: false, + limitMessage: "$Input valid path, please.$<( Min:)min>$<( Max:)max>", + history: true, + cd: true + }, options, { + keepWhitespace: false, + limit: function(value) { + var exists, stat, res; + value = replaceHomePath(value, true); + error = ""; + function mkdirParents(dirPath) { + dirPath.split(/\/|\\/).reduce(function(parents, dir) { + var path2 = pathUtil.resolve(parents += dir + pathUtil.sep); + if (!fs2.existsSync(path2)) { + fs2.mkdirSync(path2); + } else if (!fs2.statSync(path2).isDirectory()) { + throw new Error("Non directory already exists: " + path2); + } + return parents; + }, ""); + } + try { + exists = fs2.existsSync(value); + validPath = exists ? fs2.realpathSync(value) : pathUtil.resolve(value); + if (!options.hasOwnProperty("exists") && !exists || typeof options.exists === "boolean" && options.exists !== exists) { + error = (exists ? "Already exists" : "No such file or directory") + ": " + validPath; + return false; + } + if (!exists && options.create) { + if (options.isDirectory) { + mkdirParents(validPath); + } else { + mkdirParents(pathUtil.dirname(validPath)); + fs2.closeSync(fs2.openSync(validPath, "w")); + } + validPath = fs2.realpathSync(validPath); + } + if (exists && (options.min || options.max || options.isFile || options.isDirectory)) { + stat = fs2.statSync(validPath); + if (options.isFile && !stat.isFile()) { + error = "Not file: " + validPath; + return false; + } else if (options.isDirectory && !stat.isDirectory()) { + error = "Not directory: " + validPath; + return false; + } else if (options.min && stat.size < +options.min || options.max && stat.size > +options.max) { + error = "Size " + stat.size + " is out of range: " + validPath; + return false; + } + } + if (typeof options.validate === "function" && (res = options.validate(validPath)) !== true) { + if (typeof res === "string") { + error = res; + } + return false; + } + } catch (e) { + error = e + ""; + return false; + } + return true; + }, + phContent: function(param) { + return param === "error" ? error : param !== "min" && param !== "max" ? null : options.hasOwnProperty(param) ? options[param] + "" : ""; + } + }); + options = options || {}; + if (query == null) { + query = 'Input path (you can "cd" and "pwd"): '; + } + exports.question(query, readOptions); + return validPath; + }; + function getClHandler(commandHandler, options) { + var clHandler = {}, hIndex = {}; + if (typeof commandHandler === "object") { + Object.keys(commandHandler).forEach(function(cmd) { + if (typeof commandHandler[cmd] === "function") { + hIndex[options.caseSensitive ? cmd : cmd.toLowerCase()] = commandHandler[cmd]; + } + }); + clHandler.preCheck = function(res) { + var cmdKey; + clHandler.args = parseCl(res); + cmdKey = clHandler.args[0] || ""; + if (!options.caseSensitive) { + cmdKey = cmdKey.toLowerCase(); + } + clHandler.hRes = cmdKey !== "_" && hIndex.hasOwnProperty(cmdKey) ? hIndex[cmdKey].apply(res, clHandler.args.slice(1)) : hIndex.hasOwnProperty("_") ? hIndex._.apply(res, clHandler.args) : null; + return { res, forceNext: false }; + }; + if (!hIndex.hasOwnProperty("_")) { + clHandler.limit = function() { + var cmdKey = clHandler.args[0] || ""; + if (!options.caseSensitive) { + cmdKey = cmdKey.toLowerCase(); + } + return hIndex.hasOwnProperty(cmdKey); + }; + } + } else { + clHandler.preCheck = function(res) { + clHandler.args = parseCl(res); + clHandler.hRes = typeof commandHandler === "function" ? commandHandler.apply(res, clHandler.args) : true; + return { res, forceNext: false }; + }; + } + return clHandler; + } + exports.promptCL = function(commandHandler, options) { + var readOptions = margeOptions({ + hideEchoBack: false, + limitMessage: "Requested command is not available.", + caseSensitive: false, + history: true + }, options), clHandler = getClHandler(commandHandler, readOptions); + readOptions.limit = clHandler.limit; + readOptions.preCheck = clHandler.preCheck; + exports.prompt(readOptions); + return clHandler.args; + }; + exports.promptLoop = function(inputHandler, options) { + var readOptions = margeOptions({ + hideEchoBack: false, + trueValue: null, + falseValue: null, + caseSensitive: false, + history: true + }, options); + while (true) { + if (inputHandler(exports.prompt(readOptions))) { + break; + } + } + return; + }; + exports.promptCLLoop = function(commandHandler, options) { + var readOptions = margeOptions({ + hideEchoBack: false, + limitMessage: "Requested command is not available.", + caseSensitive: false, + history: true + }, options), clHandler = getClHandler(commandHandler, readOptions); + readOptions.limit = clHandler.limit; + readOptions.preCheck = clHandler.preCheck; + while (true) { + exports.prompt(readOptions); + if (clHandler.hRes) { + break; + } + } + return; + }; + exports.promptSimShell = function(options) { + return exports.prompt(margeOptions({ + hideEchoBack: false, + history: true + }, options, { + prompt: function() { + return IS_WIN ? "$>" : (process.env.USER || "") + (process.env.HOSTNAME ? "@" + process.env.HOSTNAME.replace(/\..*$/, "") : "") + ":$$ "; + }() + })); + }; + function _keyInYN(query, options, limit) { + var res; + if (query == null) { + query = "Are you sure? "; + } + if ((!options || options.guide !== false) && (query += "")) { + query = query.replace(/\s*:?\s*$/, "") + " [y/n]: "; + } + res = exports.keyIn(query, margeOptions(options, { + hideEchoBack: false, + limit, + trueValue: "y", + falseValue: "n", + caseSensitive: false + })); + return typeof res === "boolean" ? res : ""; + } + exports.keyInYN = function(query, options) { + return _keyInYN(query, options); + }; + exports.keyInYNStrict = function(query, options) { + return _keyInYN(query, options, "yn"); + }; + exports.keyInPause = function(query, options) { + if (query == null) { + query = "Continue..."; + } + if ((!options || options.guide !== false) && (query += "")) { + query = query.replace(/\s+$/, "") + " (Hit any key)"; + } + exports.keyIn(query, margeOptions({ + limit: null + }, options, { + hideEchoBack: true, + mask: "" + })); + return; + }; + exports.keyInSelect = function(items, query, options) { + var readOptions = margeOptions({ + hideEchoBack: false + }, options, { + trueValue: null, + falseValue: null, + caseSensitive: false, + phContent: function(param) { + return param === "itemsCount" ? items.length + "" : param === "firstItem" ? (items[0] + "").trim() : param === "lastItem" ? (items[items.length - 1] + "").trim() : null; + } + }), keylist = "", key2i = {}, charCode = 49, display = "\n"; + if (!Array.isArray(items) || !items.length || items.length > 35) { + throw "`items` must be Array (max length: 35)."; + } + items.forEach(function(item, i2) { + var key = String.fromCharCode(charCode); + keylist += key; + key2i[key] = i2; + display += "[" + key + "] " + (item + "").trim() + "\n"; + charCode = charCode === 57 ? 97 : charCode + 1; + }); + if (!options || options.cancel !== false) { + keylist += "0"; + key2i["0"] = -1; + display += "[0] " + (options && options.cancel != null && typeof options.cancel !== "boolean" ? (options.cancel + "").trim() : "CANCEL") + "\n"; + } + readOptions.limit = keylist; + display += "\n"; + if (query == null) { + query = "Choose one from list: "; + } + if (query += "") { + if (!options || options.guide !== false) { + query = query.replace(/\s*:?\s*$/, "") + " [$]: "; + } + display += query; + } + return key2i[exports.keyIn(display, readOptions).toLowerCase()]; + }; + exports.getRawInput = function() { + return rawInput; + }; + function _setOption(optionName, args) { + var options; + if (args.length) { + options = {}; + options[optionName] = args[0]; + } + return exports.setDefaultOptions(options)[optionName]; + } + exports.setPrint = function() { + return _setOption("print", arguments); + }; + exports.setPrompt = function() { + return _setOption("prompt", arguments); + }; + exports.setEncoding = function() { + return _setOption("encoding", arguments); + }; + exports.setMask = function() { + return _setOption("mask", arguments); + }; + exports.setBufferSize = function() { + return _setOption("bufferSize", arguments); + }; + } +}); + +// node_modules/tau-prolog/modules/core.js +var require_core = __commonJS({ + "node_modules/tau-prolog/modules/core.js"(exports, module2) { + (function() { + var version = { major: 0, minor: 3, patch: 4, status: "beta" }; + function TauFile(name, type, parent, text) { + text = text === void 0 ? "" : text; + this.name = name; + this.type = type; + this.parent = parent; + this.text = text; + this.created = Date.now() / 1e3; + this.modified = this.created; + } + TauFile.prototype.get = function(length, position) { + if (position === this.text.length) { + return "end_of_stream"; + } else if (position > this.text.length) { + return "end_of_stream"; + } else { + return this.text.substring(position, position + length); + } + }; + TauFile.prototype.eof = function(position) { + return position === this.text.length; + }; + TauFile.prototype.put = function(text, position) { + if (position === "end_of_stream") { + this.text += text; + return true; + } else if (position === "past_end_of_stream") { + return null; + } else { + this.text = this.text.substring(0, position) + text + this.text.substring(position + text.length); + return true; + } + }; + TauFile.prototype.get_byte = function(position) { + if (position === "end_of_stream") + return -1; + var index = Math.floor(position / 2); + if (this.text.length <= index) + return -1; + var code = codePointAt(this.text[Math.floor(position / 2)], 0); + if (position % 2 === 0) + return code & 255; + else + return code / 256 >>> 0; + }; + TauFile.prototype.put_byte = function(byte, position) { + var index = position === "end_of_stream" ? this.text.length : Math.floor(position / 2); + if (this.text.length < index) + return null; + var code = this.text.length === index ? -1 : codePointAt(this.text[Math.floor(position / 2)], 0); + if (position % 2 === 0) { + code = code / 256 >>> 0; + code = (code & 255) << 8 | byte & 255; + } else { + code = code & 255; + code = (byte & 255) << 8 | code & 255; + } + if (this.text.length === index) + this.text += fromCodePoint(code); + else + this.text = this.text.substring(0, index) + fromCodePoint(code) + this.text.substring(index + 1); + return true; + }; + TauFile.prototype.flush = function() { + return true; + }; + TauFile.prototype.close = function() { + this.modified = Date.now() / 1e3; + return true; + }; + TauFile.prototype.size = function() { + return this.text.length; + }; + function TauDirectory(name, parent) { + this.name = name; + this.parent = parent; + this.files = {}; + this.length = 0; + this.created = Date.now() / 1e3; + this.modified = this.created; + } + TauDirectory.prototype.lookup = function(file) { + if (this.files.hasOwnProperty(file)) + return this.files[file]; + return null; + }; + TauDirectory.prototype.push = function(name, file) { + if (!this.files.hasOwnProperty(name)) + this.length++; + this.files[name] = file; + this.modified = Date.now() / 1e3; + }; + TauDirectory.prototype.remove = function(name) { + if (this.files.hasOwnProperty(name)) { + this.length--; + delete this.files[name]; + this.modified = Date.now() / 1e3; + } + }; + TauDirectory.prototype.empty = function() { + return this.length === 0; + }; + TauDirectory.prototype.size = function() { + return 4096; + }; + tau_file_system = { + files: new TauDirectory("/", "/", null), + open: function(path2, type, mode) { + var dirs = path2.replace(/\/$/, "").split("/"); + var dir = tau_file_system.files; + var name = dirs[dirs.length - 1]; + for (var i2 = 1; i2 < dirs.length - 1; i2++) { + dir = dir.lookup(dirs[i2]); + if (!pl.type.is_directory(dir)) + return null; + } + var file = dir.lookup(name); + if (file === null) { + if (mode === "read") + return null; + file = new TauFile(name, type, dir); + dir.push(name, file); + } else if (!pl.type.is_file(file)) { + return null; + } + if (mode === "write") + file.text = ""; + return file; + }, + get: function(path2) { + var dirs = path2.replace(/\/$/, "").split("/"); + var file = tau_file_system.files; + for (var i2 = 1; i2 < dirs.length; i2++) + if (pl.type.is_directory(file)) + file = file.lookup(dirs[i2]); + else + return null; + return file; + } + }; + tau_user_input = { + buffer: "", + get: function(length, _) { + var text; + while (tau_user_input.buffer.length < length) { + text = window.prompt(); + if (text.length === 0) + return "end_of_stream"; + if (text) { + tau_user_input.buffer += text; + } + } + text = tau_user_input.buffer.substr(0, length); + tau_user_input.buffer = tau_user_input.buffer.substr(length); + return text; + }, + eof: function(_) { + return false; + } + }; + tau_user_output = { + put: function(text, _) { + console.log(text); + return true; + }, + flush: function() { + return true; + } + }; + tau_user_error = { + put: function(text, _) { + (console.error || console.log)(text); + return true; + }, + flush: function() { + return true; + } + }; + nodejs_file_system = { + open: function(path2, type, mode) { + var fd, fs2 = require("fs"); + if (mode === "read" && !fs2.existsSync(path2)) + return null; + try { + fd = fs2.openSync(path2, mode[0]); + } catch (ex) { + return false; + } + return { + get: function(length, position) { + var buffer = new Buffer(length); + fs2.readSync(fd, buffer, 0, length, position); + var end_of_file = true; + var text = buffer.toString(); + for (var i2 = 0; i2 < length && end_of_file; i2++) + end_of_file = text[i2] === "\0"; + return end_of_file ? "end_of_stream" : buffer.toString(); + }, + eof: function(position) { + var stats = fs2.statSync(path2); + return position === stats["size"]; + }, + put: function(text, position) { + var buffer = Buffer.from(text); + if (position === "end_of_stream") + fs2.writeSync(fd, buffer); + else if (position === "past_end_of_stream") + return null; + else + fs2.writeSync(fd, buffer, 0, buffer.length, position); + return true; + }, + get_byte: function(position) { + try { + var buffer = Buffer.alloc(1); + var bytesRead = fs2.readSync(fd, buffer, 0, 1, position); + var end_of_file = bytesRead < 1; + return end_of_file ? "end_of_stream" : buffer.readUInt8(0); + } catch (ex) { + return "end_of_stream"; + } + }, + put_byte: function(byte, position) { + var buffer = Buffer.from([byte]); + if (position === "end_of_stream") + fs2.writeSync(fd, buffer); + else if (position === "past_end_of_stream") + return null; + else + fs2.writeSync(fd, buffer, 0, buffer.length, position); + return true; + }, + flush: function() { + return true; + }, + close: function() { + fs2.closeSync(fd); + return true; + } + }; + } + }; + nodejs_user_input = { + buffer: "", + get: function(length, _) { + var text; + var readlineSync = require_readline_sync(); + while (nodejs_user_input.buffer.length < length) + nodejs_user_input.buffer += readlineSync.question("", { keepWhitespace: true }) + "\n"; + text = nodejs_user_input.buffer.substr(0, length); + nodejs_user_input.buffer = nodejs_user_input.buffer.substr(length); + return text; + }, + eof: function(length) { + return false; + } + }; + nodejs_user_output = { + put: function(text, _) { + process.stdout.write(text); + return true; + }, + flush: function() { + return true; + } + }; + nodejs_user_error = { + put: function(text, _) { + process.stderr.write(text); + return true; + }, + flush: function() { + return true; + } + }; + var indexOf; + if (!Array.prototype.indexOf) { + indexOf = function(array, elem) { + var len = array.length; + for (var i2 = 0; i2 < len; i2++) { + if (elem === array[i2]) + return i2; + } + return -1; + }; + } else { + indexOf = function(array, elem) { + return array.indexOf(elem); + }; + } + var reduce = function(array, fn) { + if (array.length === 0) + return void 0; + var elem = array[0]; + var len = array.length; + for (var i2 = 1; i2 < len; i2++) { + elem = fn(elem, array[i2]); + } + return elem; + }; + var map; + if (!Array.prototype.map) { + map = function(array, fn) { + var a = []; + var len = array.length; + for (var i2 = 0; i2 < len; i2++) { + a.push(fn(array[i2])); + } + return a; + }; + } else { + map = function(array, fn) { + return array.map(fn); + }; + } + var filter; + if (!Array.prototype.filter) { + filter = function(array, fn) { + var a = []; + var len = array.length; + for (var i2 = 0; i2 < len; i2++) { + if (fn(array[i2])) + a.push(array[i2]); + } + return a; + }; + } else { + filter = function(array, fn) { + return array.filter(fn); + }; + } + var codePointAt; + if (!String.prototype.codePointAt) { + codePointAt = function(str, i2) { + return str.charCodeAt(i2); + }; + } else { + codePointAt = function(str, i2) { + return str.codePointAt(i2); + }; + } + var fromCodePoint; + if (!String.fromCodePoint) { + fromCodePoint = function() { + return String.fromCharCode.apply(null, arguments); + }; + } else { + fromCodePoint = function() { + return String.fromCodePoint.apply(null, arguments); + }; + } + var stringLength; + var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + if (Array.from) + stringLength = function(str) { + return Array.from(str).length; + }; + else + stringLength = function(str) { + return str.replace(regexAstralSymbols, "_").length; + }; + var ERROR = 0; + var SUCCESS = 1; + var regex_escape = /(\\a)|(\\b)|(\\d)|(\\e)|(\\f)|(\\n)|(\\r)|(\\s)|(\\t)|(\\v)|\\x([0-9a-fA-F]+)\\|\\([0-7]+)\\|(\\\\)|(\\')|('')|(\\")|(\\`)|(\\.)|(.)/g; + var escape_map = { "\\a": 7, "\\b": 8, "\\d": 127, "\\e": 27, "\\f": 12, "\\n": 10, "\\r": 13, "\\s": 32, "\\t": 9, "\\v": 11 }; + function escape(str) { + var stack = []; + var _error = false; + str.replace(regex_escape, function(match, a, b, d, e, f, n, r, s, t, v, hex, octal, back, single, dsingle, double, backquote, error, char) { + switch (true) { + case hex !== void 0: + stack.push(parseInt(hex, 16)); + return ""; + case octal !== void 0: + stack.push(parseInt(octal, 8)); + return ""; + case back !== void 0: + case single !== void 0: + case dsingle !== void 0: + case double !== void 0: + case backquote !== void 0: + stack.push(codePointAt(match.substr(1), 0)); + return ""; + case char !== void 0: + stack.push(codePointAt(char, 0)); + return ""; + case error !== void 0: + _error = true; + default: + stack.push(escape_map[match]); + return ""; + } + }); + if (_error) + return null; + return stack; + } + function escapeAtom(str, quote) { + var atom = ""; + if (str === "\\") + return null; + if (str.length < 2) + return str; + try { + str = str.replace(/((?:\\\\)+)|\\([0-7]+)\\/g, function(match, g1, g2) { + return g1 || fromCodePoint(parseInt(g2, 8)); + }); + str = str.replace(/((?:\\\\)+)|\\x([0-9a-fA-F]+)\\/g, function(match, g1, g2) { + return g1 || fromCodePoint(parseInt(g2, 16)); + }); + str = str.replace(/((?:\\\\)+)|\\u([0-9a-fA-F]{4})/g, function(match, g1, g2) { + return g1 || fromCodePoint(parseInt(g2, 16)); + }); + } catch (error) { + return null; + } + for (var i2 = 0; i2 < str.length; i2++) { + var a = str.charAt(i2); + var b = str.charAt(i2 + 1); + if (a === quote && b === quote) { + i2++; + atom += quote; + } else if (a === "\\") { + if (["a", "b", "f", "n", "r", "t", "v", "'", '"', "\\", "a", "\b", "\f", "\n", "\r", " ", "\v"].indexOf(b) !== -1) { + i2 += 1; + switch (b) { + case "a": + atom += "a"; + break; + case "b": + atom += "\b"; + break; + case "f": + atom += "\f"; + break; + case "n": + atom += "\n"; + break; + case "r": + atom += "\r"; + break; + case "t": + atom += " "; + break; + case "v": + atom += "\v"; + break; + case "'": + atom += "'"; + break; + case '"': + atom += '"'; + break; + case "\\": + atom += "\\"; + break; + } + } else { + return null; + } + } else { + atom += a; + } + } + return atom; + } + function redoEscape(str) { + var atom = ""; + for (var i2 = 0; i2 < str.length; i2++) { + switch (str.charAt(i2)) { + case "'": + atom += "\\'"; + break; + case "\\": + atom += "\\\\"; + break; + case "\b": + atom += "\\b"; + break; + case "\f": + atom += "\\f"; + break; + case "\n": + atom += "\\n"; + break; + case "\r": + atom += "\\r"; + break; + case " ": + atom += "\\t"; + break; + case "\v": + atom += "\\v"; + break; + default: + atom += str.charAt(i2); + break; + } + } + return atom; + } + function convertNum(num) { + var n = num.substr(2); + switch (num.substr(0, 2).toLowerCase()) { + case "0x": + return parseInt(n, 16); + case "0b": + return parseInt(n, 2); + case "0o": + return parseInt(n, 8); + case "0'": + return escape(n)[0]; + default: + return parseFloat(num); + } + } + function is_graphic_token(string) { + return /^[#\$\&\*\+\-\.\/\:\<\=\>\?\@\^\~\\]+/.test(string); + } + var rules = { + whitespace: /^\s*(?:(?:%.*)|(?:\/\*(?:\n|\r|.)*?(?:\*\/|$))|(?:\s+))\s*/, + variable: /^(?:[A-Z_][a-zA-Z0-9_]*)/, + atom: /^(\!|,|;|[a-z][0-9a-zA-Z_]*|[#\$\&\*\+\-\.\/\:\<\=\>\?\@\^\~\\]+|'(?:(?:'')|(?:\\\\)|(?:\\')|[^'])*')/, + number: /^(?:0o[0-7]+|0x[0-9a-fA-F]+|0b[01]+|0'(?:''|\\[abdefnrstv\\'"`]|\\x?\d+\\|[^\\])|\d+(?:\.\d+(?:[eE][+-]?\d+)?)?)/, + string: /^(?:"([^"]|""|\\")*"|`([^`]|``|\\`)*`)/, + l_brace: /^(?:\[)/, + r_brace: /^(?:\])/, + l_bracket: /^(?:\{)/, + r_bracket: /^(?:\})/, + bar: /^(?:\|)/, + l_paren: /^(?:\()/, + r_paren: /^(?:\))/ + }; + function replace(thread, text) { + if (thread.get_flag("char_conversion").id === "on") { + return text.replace(/./g, function(char) { + return thread.get_char_conversion(char); + }); + } + return text; + } + function Tokenizer(thread) { + this.thread = thread; + this.text = ""; + this.tokens = []; + } + Tokenizer.prototype.set_last_tokens = function(tokens) { + return this.tokens = tokens; + }; + Tokenizer.prototype.new_text = function(text) { + this.text = text; + this.tokens = []; + }; + Tokenizer.prototype.get_tokens = function(init) { + var text; + var len = 0; + var line = 0; + var start = 0; + var tokens = []; + var last_is_blank; + if (init) { + var token = this.tokens[init - 1]; + len = token.len; + text = replace(this.thread, this.text.substr(token.len)); + line = token.line; + start = token.start; + } else + text = this.text; + if (/^\s*$/.test(text)) + return null; + while (text !== "") { + var matches = []; + last_is_blank = false; + if (/^\n/.exec(text) !== null) { + line++; + start = 0; + len++; + text = text.replace(/\n/, ""); + last_is_blank = true; + continue; + } + for (var rule in rules) { + if (rules.hasOwnProperty(rule)) { + var matchs = rules[rule].exec(text); + if (matchs) { + matches.push({ + value: matchs[0], + name: rule, + matches: matchs + }); + } + } + } + if (!matches.length) + return this.set_last_tokens([{ value: text, matches: [], name: "lexical", line, start }]); + var token = reduce(matches, function(a, b) { + return a.value.length >= b.value.length ? a : b; + }); + token.start = start; + token.line = line; + text = text.replace(token.value, ""); + start += token.value.length; + len += token.value.length; + var nl = (token.value.match(/\n/g) || []).length; + line += nl; + if (nl > 0) + start = token.value.length - token.value.lastIndexOf("\n") - 1; + token.line_count = line; + token.line_position = start; + switch (token.name) { + case "atom": + token.raw = token.value; + if (token.value.charAt(0) === "'") { + token.value = escapeAtom(token.value.substring(1, token.value.length - 1), "'"); + if (token.value === null) { + token.name = "lexical"; + token.value = token.raw; + token.error = "unknown_escape_sequence"; + } + } + break; + case "number": + var substr = token.value.substring(0, 2); + token.raw = token.value; + token.float = substr !== "0x" && substr !== "0'" && token.value.match(/[.eE]/) !== null; + token.value = convertNum(token.value); + token.blank = last_is_blank; + if (!token.float && pl.flag.bounded.value.indicator === "true/0" && token.value > pl.flag.max_integer.value.value) { + token.name = "lexical"; + token.value = token.raw; + token.error = "int_overflow"; + } + break; + case "string": + var del = token.value.charAt(0); + token.raw = token.value; + token.value = escapeAtom(token.value.substring(1, token.value.length - 1), del); + if (token.value === null) { + token.name = "lexical"; + token.value = token.raw; + token.error = "unknown_escape_sequence"; + } + break; + case "whitespace": + var last = tokens[tokens.length - 1]; + if (last) + last.space = true; + last_is_blank = true; + continue; + case "r_bracket": + if (tokens.length > 0 && tokens[tokens.length - 1].name === "l_bracket") { + token = tokens.pop(); + token.name = "atom"; + token.value = "{}"; + token.raw = "{}"; + token.space = false; + } + break; + case "r_brace": + if (tokens.length > 0 && tokens[tokens.length - 1].name === "l_brace") { + token = tokens.pop(); + token.name = "atom"; + token.value = "[]"; + token.raw = "[]"; + token.space = false; + } + break; + } + token.len = len; + tokens.push(token); + last_is_blank = false; + } + var t = this.set_last_tokens(tokens); + return t.length === 0 ? null : t; + }; + function parseExpr(thread, tokens, start, priority, toplevel) { + if (!tokens[start]) + return { type: ERROR, value: pl.error.syntax(tokens[start - 1], "expression expected", true) }; + var error; + if (priority === "0") { + var token = tokens[start]; + switch (token.name) { + case "number": + return { type: SUCCESS, len: start + 1, value: new pl.type.Num(token.value, token.float) }; + case "variable": + return { type: SUCCESS, len: start + 1, value: new pl.type.Var(token.value) }; + case "string": + var str; + switch (thread.get_flag("double_quotes").id) { + case "atom": + ; + str = new Term(token.value, []); + break; + case "codes": + str = new Term("[]", []); + for (var i2 = token.value.length - 1; i2 >= 0; i2--) + str = new Term(".", [new pl.type.Num(codePointAt(token.value, i2), false), str]); + break; + case "chars": + str = new Term("[]", []); + for (var i2 = token.value.length - 1; i2 >= 0; i2--) + str = new Term(".", [new pl.type.Term(token.value.charAt(i2), []), str]); + break; + } + return { type: SUCCESS, len: start + 1, value: str }; + case "l_paren": + var expr = parseExpr(thread, tokens, start + 1, thread.__get_max_priority(), true); + if (expr.type !== SUCCESS) + return expr; + if (tokens[expr.len] && tokens[expr.len].name === "r_paren") { + expr.len++; + return expr; + } + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[expr.len] ? tokens[expr.len] : tokens[expr.len - 1], ") or operator expected", !tokens[expr.len]) }; + case "l_bracket": + var expr = parseExpr(thread, tokens, start + 1, thread.__get_max_priority(), true); + if (expr.type !== SUCCESS) + return expr; + if (tokens[expr.len] && tokens[expr.len].name === "r_bracket") { + expr.len++; + expr.value = new Term("{}", [expr.value]); + return expr; + } + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[expr.len] ? tokens[expr.len] : tokens[expr.len - 1], "} or operator expected", !tokens[expr.len]) }; + } + var result = parseTerm(thread, tokens, start, toplevel); + if (result.type === SUCCESS || result.derived) + return result; + result = parseList(thread, tokens, start); + if (result.type === SUCCESS || result.derived) + return result; + return { type: ERROR, derived: false, value: pl.error.syntax(tokens[start], token.error || "unexpected token") }; + } + var max_priority = thread.__get_max_priority(); + var next_priority = thread.__get_next_priority(priority); + var aux_start = start; + if (tokens[start].name === "atom" && tokens[start + 1] && (tokens[start].space || tokens[start + 1].name !== "l_paren")) { + var token = tokens[start++]; + var classes = thread.__lookup_operator_classes(priority, token.value); + if (classes && classes.indexOf("fy") > -1) { + var expr = parseExpr(thread, tokens, start, priority, toplevel); + if (expr.type !== ERROR) { + if (token.value === "-" && !token.space && pl.type.is_number(expr.value)) { + return { + value: new pl.type.Num(-expr.value.value, expr.value.is_float), + len: expr.len, + type: SUCCESS + }; + } else { + return { + value: new pl.type.Term(token.value, [expr.value]), + len: expr.len, + type: SUCCESS + }; + } + } else { + error = expr; + } + } else if (classes && classes.indexOf("fx") > -1) { + var expr = parseExpr(thread, tokens, start, next_priority, toplevel); + if (expr.type !== ERROR) { + return { + value: new pl.type.Term(token.value, [expr.value]), + len: expr.len, + type: SUCCESS + }; + } else { + error = expr; + } + } + } + start = aux_start; + var expr = parseExpr(thread, tokens, start, next_priority, toplevel); + if (expr.type === SUCCESS) { + start = expr.len; + var token = tokens[start]; + if (tokens[start] && (tokens[start].name === "atom" && thread.__lookup_operator_classes(priority, token.value) || tokens[start].name === "bar" && thread.__lookup_operator_classes(priority, "|"))) { + var next_priority_lt = next_priority; + var next_priority_eq = priority; + var classes = thread.__lookup_operator_classes(priority, token.value); + if (classes.indexOf("xf") > -1) { + return { + value: new pl.type.Term(token.value, [expr.value]), + len: ++expr.len, + type: SUCCESS + }; + } else if (classes.indexOf("xfx") > -1) { + var expr2 = parseExpr(thread, tokens, start + 1, next_priority_lt, toplevel); + if (expr2.type === SUCCESS) { + return { + value: new pl.type.Term(token.value, [expr.value, expr2.value]), + len: expr2.len, + type: SUCCESS + }; + } else { + expr2.derived = true; + return expr2; + } + } else if (classes.indexOf("xfy") > -1) { + var expr2 = parseExpr(thread, tokens, start + 1, next_priority_eq, toplevel); + if (expr2.type === SUCCESS) { + return { + value: new pl.type.Term(token.value, [expr.value, expr2.value]), + len: expr2.len, + type: SUCCESS + }; + } else { + expr2.derived = true; + return expr2; + } + } else if (expr.type !== ERROR) { + while (true) { + start = expr.len; + var token = tokens[start]; + if (token && token.name === "atom" && thread.__lookup_operator_classes(priority, token.value)) { + var classes = thread.__lookup_operator_classes(priority, token.value); + if (classes.indexOf("yf") > -1) { + expr = { + value: new pl.type.Term(token.value, [expr.value]), + len: ++start, + type: SUCCESS + }; + } else if (classes.indexOf("yfx") > -1) { + var expr2 = parseExpr(thread, tokens, ++start, next_priority_lt, toplevel); + if (expr2.type === ERROR) { + expr2.derived = true; + return expr2; + } + start = expr2.len; + expr = { + value: new pl.type.Term(token.value, [expr.value, expr2.value]), + len: start, + type: SUCCESS + }; + } else { + break; + } + } else { + break; + } + } + } + } else { + error = { type: ERROR, value: pl.error.syntax(tokens[expr.len - 1], "operator expected") }; + } + return expr; + } + return expr; + } + function parseTerm(thread, tokens, start, toplevel) { + if (!tokens[start] || tokens[start].name === "atom" && tokens[start].raw === "." && !toplevel && (tokens[start].space || !tokens[start + 1] || tokens[start + 1].name !== "l_paren")) + return { type: ERROR, derived: false, value: pl.error.syntax(tokens[start - 1], "unfounded token") }; + var atom = tokens[start]; + var exprs = []; + if (tokens[start].name === "atom" && tokens[start].raw !== ",") { + start++; + if (tokens[start - 1].space) + return { type: SUCCESS, len: start, value: new pl.type.Term(atom.value, exprs) }; + if (tokens[start] && tokens[start].name === "l_paren") { + if (tokens[start + 1] && tokens[start + 1].name === "r_paren") + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start + 1], "argument expected") }; + var expr = parseExpr(thread, tokens, ++start, "999", true); + if (expr.type === ERROR) { + if (expr.derived) + return expr; + else + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start - 1], "argument expected", !tokens[start]) }; + } + exprs.push(expr.value); + start = expr.len; + while (tokens[start] && tokens[start].name === "atom" && tokens[start].value === ",") { + expr = parseExpr(thread, tokens, start + 1, "999", true); + if (expr.type === ERROR) { + if (expr.derived) + return expr; + else + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start + 1] ? tokens[start + 1] : tokens[start], "argument expected", !tokens[start + 1]) }; + } + exprs.push(expr.value); + start = expr.len; + } + if (tokens[start] && tokens[start].name === "r_paren") + start++; + else + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start - 1], ", or ) expected", !tokens[start]) }; + } + return { type: SUCCESS, len: start, value: new pl.type.Term(atom.value, exprs) }; + } + return { type: ERROR, derived: false, value: pl.error.syntax(tokens[start], "term expected") }; + } + function parseList(thread, tokens, start) { + if (!tokens[start]) + return { type: ERROR, derived: false, value: pl.error.syntax(tokens[start - 1], "[ expected") }; + if (tokens[start] && tokens[start].name === "l_brace") { + var expr = parseExpr(thread, tokens, ++start, "999", true); + var exprs = [expr.value]; + var cons = void 0; + if (expr.type === ERROR) { + if (tokens[start] && tokens[start].name === "r_brace") { + return { type: SUCCESS, len: start + 1, value: new pl.type.Term("[]", []) }; + } + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start], "] expected") }; + } + start = expr.len; + while (tokens[start] && tokens[start].name === "atom" && tokens[start].value === ",") { + expr = parseExpr(thread, tokens, start + 1, "999", true); + if (expr.type === ERROR) { + if (expr.derived) + return expr; + else + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start + 1] ? tokens[start + 1] : tokens[start], "argument expected", !tokens[start + 1]) }; + } + exprs.push(expr.value); + start = expr.len; + } + var bar = false; + if (tokens[start] && tokens[start].name === "bar") { + bar = true; + expr = parseExpr(thread, tokens, start + 1, "999", true); + if (expr.type === ERROR) { + if (expr.derived) + return expr; + else + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start + 1] ? tokens[start + 1] : tokens[start], "argument expected", !tokens[start + 1]) }; + } + cons = expr.value; + start = expr.len; + } + if (tokens[start] && tokens[start].name === "r_brace") + return { type: SUCCESS, len: start + 1, value: arrayToList(exprs, cons) }; + else + return { type: ERROR, derived: true, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start - 1], bar ? "] expected" : ", or | or ] expected", !tokens[start]) }; + } + return { type: ERROR, derived: false, value: pl.error.syntax(tokens[start], "list expected") }; + } + function parseRule(thread, tokens, start) { + var line = tokens[start].line; + var expr = parseExpr(thread, tokens, start, thread.__get_max_priority(), false); + var rule = null; + var obj; + if (expr.type !== ERROR) { + start = expr.len; + if (tokens[start] && tokens[start].name === "atom" && tokens[start].raw === ".") { + start++; + if (pl.type.is_term(expr.value)) { + if (expr.value.indicator === ":-/2") { + rule = new pl.type.Rule(expr.value.args[0], body_conversion(expr.value.args[1])); + obj = { + value: rule, + len: start, + type: SUCCESS + }; + } else if (expr.value.indicator === "-->/2") { + rule = new pl.type.Rule(expr.value.args[0], body_conversion(expr.value.args[1])); + rule = rule_to_dcg(rule, thread); + rule.body = body_conversion(rule.body); + if (!pl.type.is_rule(rule)) + return { + value: rule, + len: start, + type: ERROR + }; + obj = { + value: rule, + len: start, + type: pl.type.is_rule(rule) ? SUCCESS : ERROR + }; + } else { + rule = new pl.type.Rule(expr.value, null); + obj = { + value: rule, + len: start, + type: SUCCESS + }; + } + if (rule) { + var singleton = rule.singleton_variables(); + if (singleton.length > 0) + thread.throw_warning(pl.warning.singleton(singleton, rule.head.indicator, line)); + } + return obj; + } else { + return { type: ERROR, value: pl.error.syntax(tokens[start], "callable expected") }; + } + } else { + return { type: ERROR, value: pl.error.syntax(tokens[start] ? tokens[start] : tokens[start - 1], ". or operator expected") }; + } + } + return expr; + } + function parseProgram(thread, string, options) { + var opts = {}; + options = options ? options : {}; + opts.success = options.success ? options.success : function() { + }; + opts.error = options.error ? options.error : function() { + }; + opts.from = options.from ? options.from : "$tau-js"; + opts.reconsult = options.reconsult !== void 0 ? options.reconsult : true; + opts.reconsulted = options.reconsulted === void 0 ? {} : options.reconsulted; + opts.context_module = options.context_module === void 0 ? "user" : options.context_module; + opts.initialization = options.initialization === void 0 ? [] : options.initialization; + opts.current_token = options.current_token === void 0 ? 0 : options.current_token; + opts.tokenizer = options.tokenizer === void 0 ? null : options.tokenizer; + opts.tokens = options.tokens === void 0 ? null : options.tokens; + opts.string = string; + opts.term_expansion = false; + var reconsulted = opts.reconsulted; + var tokenizer = opts.tokenizer; + var tokens = opts.tokens; + if (tokenizer === null) { + tokenizer = new Tokenizer(thread); + tokenizer.new_text(string); + opts.tokenizer = tokenizer; + tokens = tokenizer.get_tokens(0); + opts.tokens = tokens; + } + var n = opts.current_token; + while (tokens !== null && tokens[n]) { + var expr = parseRule(thread, tokens, n); + opts.current_token = expr.len; + if (expr.type === ERROR) { + if (opts.error !== void 0) + opts.error(new Term("throw", [expr.value])); + return; + } else { + var context_module = opts.context_module; + var term_expansion = thread.session.modules[context_module].rules["term_expansion/2"]; + if (term_expansion && term_expansion.length > 0) { + opts.term_expansion = true; + var n_thread = new Thread(thread.session); + var term = expr.value.body ? new Term(":-", [expr.value.head, expr.value.body]) : expr.value.head; + thread.session.renamed_variables = {}; + term = term.rename(thread.session); + n_thread.query(context_module + ":term_expansion(" + term.toString({ quoted: true }) + ", X)."); + n_thread.answer(function(thread2, opts2, reconsulted2, expr2) { + return function(answer) { + if (answer && !pl.type.is_error(answer) && pl.type.is_term(answer.links["X"])) { + var term2 = answer.links["X"]; + var rule = term2.indicator === ":-/2" ? new Rule(term2.args[0], term2.args[1]) : new Rule(term2, null); + parseProgramExpansion(thread2, opts2, reconsulted2, { value: rule, len: expr2.len, type: expr2.type }); + } else { + parseProgramExpansion(thread2, opts2, reconsulted2, expr2); + } + }; + }(thread, opts, reconsulted, expr)); + return; + } else { + opts.term_expansion = false; + var async = parseProgramExpansion(thread, opts, reconsulted, expr); + if (async) + return; + n = expr.len; + } + } + } + var callback = opts.success; + var nthread = new Thread(thread.session); + for (var i2 = opts.initialization.length - 1; i2 > 0; i2--) { + var next_callback = function(init, callback2) { + return function(answer) { + if (answer === null) { + nthread.answer(); + } else if (pl.type.is_error(answer)) { + opts.error(answer); + } else { + nthread.add_goal(init); + nthread.answer(callback2); + } + }; + }(opts.initialization[i2], callback); + callback = next_callback; + } + if (opts.initialization.length > 0) { + nthread.add_goal(opts.initialization[0]); + nthread.answer(callback); + } else { + callback(); + } + } + function parseGoalExpansion(thread, options, expr) { + var n_thread = new Thread(thread.session); + n_thread.__goal_expansion = true; + var varterm = thread.next_free_variable(); + var varhead = thread.next_free_variable(); + var goal = varhead + " = " + expr.value.head + ", goal_expansion(" + expr.value.body.toString({ + quoted: true + }) + ", " + varterm.toString({ + quoted: true + }) + ")."; + n_thread.query(goal); + n_thread.answer(function(answer) { + if (answer && !pl.type.is_error(answer) && answer.links[varterm]) { + expr.value.head = answer.links[varhead]; + expr.value.body = body_conversion(answer.links[varterm]); + parseGoalExpansion(thread, options, expr); + } else { + thread.add_rule(expr.value, options); + parseProgram(thread, options.string, options); + } + }); + } + function parseQueryExpansion(thread, term, options) { + var n_thread = new Thread(thread.session); + n_thread.__goal_expansion = true; + var varterm = thread.next_free_variable(); + var goal = "goal_expansion(" + term.toString({ + quoted: true + }) + ", " + varterm.toString({ + quoted: true + }) + ")."; + n_thread.query(goal); + var variables = n_thread.head_point().substitution.domain(); + n_thread.answer(function(answer) { + if (answer && !pl.type.is_error(answer) && answer.links[varterm]) { + for (var i2 = 0; i2 < variables.length; i2++) { + if (variables[i2] !== varterm.id && answer.links[variables[i2]]) { + var subs = new Substitution(); + subs.links[answer.links[variables[i2]]] = variables[i2]; + answer.links[varterm] = answer.links[varterm].apply(subs); + } + } + parseQueryExpansion(thread, body_conversion(answer.links[varterm]), options); + } else { + thread.add_goal(term); + options.success(term); + parseQuery(thread, options.string, options); + } + }); + } + function parseProgramExpansion(thread, options, reconsulted, expr) { + var async = options.term_expansion === true; + if (expr.value.body === null && expr.value.head.indicator === "?-/1") { + async = true; + var n_thread = new Thread(thread.session); + n_thread.add_goal(expr.value.head.args[0]); + n_thread.answer(function(answer) { + if (pl.type.is_error(answer)) { + thread.throw_warning(answer.args[0]); + } else if (answer === false || answer === null) { + thread.throw_warning(pl.warning.failed_goal(expr.value.head.args[0], expr.len)); + } + parseProgram(thread, options.string, options); + }); + } else if (expr.value.body === null && expr.value.head.indicator === ":-/1") { + var result = thread.run_directive(expr.value.head.args[0], options); + async = async || result === true; + if (async) + parseProgram(thread, options.string, options); + } else { + var context_module = options.context_module; + var indicator2 = expr.value.head.indicator; + if (expr.value.head.indicator === ":/2") { + context_module = expr.value.head.args[0].id; + indicator2 = expr.value.head.args[1].indicator; + } + if (!reconsulted.hasOwnProperty(context_module)) + reconsulted[context_module] = {}; + if (options.reconsult !== false && reconsulted[context_module][indicator2] !== true && !thread.is_multifile_predicate(indicator2)) { + var get_module = thread.session.modules[context_module]; + if (context_module !== "system" && get_module && get_module.rules[indicator2]) { + get_module.rules[indicator2] = filter(get_module.rules[indicator2], function(rule) { + return rule.dynamic; + }); + get_module.update_indices_predicate(indicator2); + } + reconsulted[context_module][indicator2] = true; + } + var goal_expansion = thread.session.modules.user.rules["goal_expansion/2"]; + if (expr.value.body !== null && goal_expansion && goal_expansion.length > 0) { + async = true; + thread.session.renamed_variables = {}; + var origin = { + head: function() { + return expr.value.head; + }, + term: function() { + return expr.value.body; + }, + set: function(h, p) { + expr.value.head = h; + expr.value.body = p; + } + }; + parseGoalExpansion(thread, options, expr, body_conversion(expr.value.body), origin.set, origin); + } else { + thread.add_rule(expr.value, options); + if (async) + parseProgram(thread, options.string, options); + } + } + return async; + } + function parseQuery(thread, string, options) { + var opts = {}; + var callback = typeof options === "function" ? options : function() { + }; + options = options === void 0 || typeof options === "function" ? {} : options; + opts.success = options.success === void 0 ? callback : options.success; + opts.error = options.error === void 0 ? callback : options.error; + opts.tokenizer = options.tokenizer === void 0 ? null : options.tokenizer; + opts.current_token = options.current_token === void 0 ? 0 : options.current_token; + opts.string = string; + var tokenizer = opts.tokenizer; + var n = opts.current_token; + if (tokenizer === null) { + tokenizer = new Tokenizer(thread); + opts.tokenizer = tokenizer; + tokenizer.new_text(string); + } + do { + var tokens = tokenizer.get_tokens(n); + if (tokens === null) + break; + var expr = parseExpr(thread, tokens, 0, thread.__get_max_priority(), false); + if (expr.type !== ERROR) { + var expr_position = expr.len; + n = expr.len + 1; + opts.current_token = n; + if (tokens[expr_position] && tokens[expr_position].name === "atom" && tokens[expr_position].raw === ".") { + expr.value = body_conversion(expr.value); + var goal_expansion = thread.session.modules.user.rules["goal_expansion/2"]; + if (!thread.__goal_expansion && goal_expansion && goal_expansion.length > 0) { + parseQueryExpansion(thread, expr.value, opts); + return; + } else { + thread.add_goal(expr.value); + opts.success(expr.value); + } + } else { + var token = tokens[expr_position]; + opts.error( + new Term("throw", [ + pl.error.syntax( + token ? token : tokens[expr_position - 1], + token && token.error ? token.error : ". or operator expected", + !token + ) + ]) + ); + return; + } + } else { + opts.error(new Term("throw", [expr.value])); + return; + } + } while (true); + } + function rule_to_dcg(rule, thread) { + thread.session.renamed_variables = {}; + rule = rule.rename(thread); + var begin = thread.next_free_variable(); + var dcg = body_to_dcg(rule.body, begin, thread); + if (dcg.error) + return dcg.value; + rule.body = dcg.value; + if (rule.head.indicator === ",/2") { + var terminals = rule.head.args[1]; + rule.head = rule.head.args[0]; + var last = thread.next_free_variable(); + var pointer = terminals; + if (!pl.type.is_list(pointer)) { + return pl.error.type("list", pointer, "DCG/0"); + } + if (pointer.indicator === "[]/0") { + terminals = dcg.variable; + } else { + while (pointer.indicator === "./2" && pl.type.is_list(pointer) && pointer.args[1].indicator !== "[]/0") { + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) + return pl.error.instantiation("DCG/0"); + else if (!pl.type.is_list(pointer)) + return pl.error.type("list", terminals, "DCG/0"); + pointer.args[1] = dcg.variable; + } + rule.body = new Term(",", [rule.body, new Term("=", [last, terminals])]); + rule.head = new Term(rule.head.id, rule.head.args.concat([begin, last])); + } else { + var first_assign = rule.body; + if (pl.type.is_term(first_assign) && first_assign.indicator === ",/2") + first_assign = first_assign.args[0]; + if (pl.type.is_term(first_assign) && first_assign.indicator === "=/2" && pl.type.is_variable(first_assign.args[0]) && first_assign.args[0] === begin) { + begin = first_assign.args[1]; + rule.body = rule.body.replace(null); + } + if (rule.head.indicator === ":/2") + rule.head = new Term(":", [ + new Term(rule.head.args[0].id, []), + new Term(rule.head.args[1].id, rule.head.args[1].args.concat([begin, dcg.variable])) + ]); + else + rule.head = new Term(rule.head.id, rule.head.args.concat([begin, dcg.variable])); + } + return rule; + } + function body_to_dcg(expr, last, thread) { + var free; + if (pl.type.is_term(expr) && expr.indicator === "!/0") { + free = thread.next_free_variable(); + return { + value: new Term(",", [expr, new Term("=", [last, free])]), + variable: free, + error: false + }; + } else if (pl.type.is_term(expr) && expr.indicator === ":/2") { + var right = body_to_dcg(expr.args[1], last, thread); + if (right.error) + return right; + return { + value: new Term(":", [expr.args[0], right.value]), + variable: right.variable, + error: false + }; + } else if (pl.type.is_term(expr) && expr.indicator === "\\+/1") { + var left = body_to_dcg(expr.args[0], last, thread); + if (left.error) + return left; + free = thread.next_free_variable(); + return { + value: new Term(",", [new Term(expr.id, [left.value]), new Term("=", [last, free])]), + variable: free, + error: false + }; + } else if (pl.type.is_term(expr) && (expr.indicator === ",/2" || expr.indicator === "->/2")) { + var left = body_to_dcg(expr.args[0], last, thread); + if (left.error) + return left; + var right = body_to_dcg(expr.args[1], left.variable, thread); + if (right.error) + return right; + return { + value: new Term(expr.id, [left.value, right.value]), + variable: right.variable, + error: false + }; + } else if (pl.type.is_term(expr) && expr.indicator === ";/2") { + var left = body_to_dcg(expr.args[0], last, thread); + if (left.error) + return left; + var right = body_to_dcg(expr.args[1], last, thread); + if (right.error) + return right; + return { + value: new Term(",", [new Term(";", [left.value, right.value]), new Term("=", [left.variable, right.variable])]), + variable: right.variable, + error: false + }; + } else if (pl.type.is_term(expr) && expr.indicator === "{}/1") { + free = thread.next_free_variable(); + return { + value: new Term(",", [expr.args[0], new Term("=", [last, free])]), + variable: free, + error: false + }; + } else if (pl.type.is_empty_list(expr)) { + return { + value: new Term("true", []), + variable: last, + error: false + }; + } else if (pl.type.is_list(expr)) { + free = thread.next_free_variable(); + var pointer = expr; + var prev; + while (pointer.indicator === "./2") { + prev = pointer; + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) { + return { + value: pl.error.instantiation("DCG/0"), + variable: last, + error: true + }; + } else if (!pl.type.is_empty_list(pointer)) { + return { + value: pl.error.type("list", expr, "DCG/0"), + variable: last, + error: true + }; + } else { + prev.args[1] = free; + return { + value: new Term("=", [last, expr]), + variable: free, + error: false + }; + } + } else if (pl.type.is_callable(expr)) { + free = thread.next_free_variable(); + expr = new Term(expr.id, expr.args.concat([last, free])); + return { + value: expr, + variable: free, + error: false + }; + } else { + return { + value: pl.error.type("callable", expr, "DCG/0"), + variable: last, + error: true + }; + } + } + function body_conversion(expr) { + if (pl.type.is_variable(expr)) + return new Term("call", [expr]); + else if (pl.type.is_term(expr) && [",/2", ";/2", "->/2"].indexOf(expr.indicator) !== -1) + return new Term(expr.id, [body_conversion(expr.args[0]), body_conversion(expr.args[1])]); + else if (pl.type.is_term(expr) && expr.indicator === ":/2") { + var body = body_conversion(expr.args[1]); + return new Term(":", [expr.args[0], body]); + } + return expr; + } + function arrayToList(array, cons) { + var list = cons ? cons : new Term("[]", []); + for (var i2 = array.length - 1; i2 >= 0; i2--) + list = new Term(".", [array[i2], list]); + return list; + } + function difference(xs, ys) { + var zs = []; + for (var i2 = 0; i2 < xs.length; i2++) { + if (indexOf(zs, xs[i2]) === -1 && indexOf(ys, xs[i2]) === -1) + zs.push(xs[i2]); + } + return zs; + } + function remove(array, element) { + for (var i2 = array.length - 1; i2 >= 0; i2--) { + if (array[i2] === element) { + array.splice(i2, 1); + } + } + } + function nub(array) { + var seen = {}; + var unique = []; + for (var i2 = 0; i2 < array.length; i2++) { + if (!(array[i2] in seen)) { + unique.push(array[i2]); + seen[array[i2]] = true; + } + } + return unique; + } + function retract(thread, point, indicator2, rule, get_module) { + if (get_module.rules[indicator2]) { + for (var i2 = 0; i2 < get_module.rules[indicator2].length; i2++) { + if (get_module.rules[indicator2][i2] === rule) { + get_module.rules[indicator2].splice(i2, 1); + get_module.update_indices_predicate(indicator2); + thread.success(point); + break; + } + } + } + } + function callN(n) { + return function(thread, point, atom) { + var closure = atom.args[0], args = atom.args.slice(1, n); + var module_atom; + if (pl.type.is_term(closure) && closure.indicator === ":/2") { + if (!pl.type.is_atom(closure.args[0])) { + thread.throw_error(pl.error.type("module", closure.args[0], atom.indicator)); + return; + } + module_atom = closure.args[0]; + closure = closure.args[1]; + } + if (pl.type.is_variable(closure)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(closure)) { + thread.throw_error(pl.error.type("callable", closure, atom.indicator)); + } else { + var goal = body_conversion(new Term(closure.id, closure.args.concat(args))); + if (!pl.type.is_callable(goal)) { + thread.throw_error(pl.error.type("callable", goal, atom.indicator)); + return; + } + if (module_atom) + goal = new Term(":", [module_atom, goal]); + thread.prepend([new State(point.goal.replace(goal), point.substitution, point)]); + } + }; + } + function str_indicator(str) { + for (var i2 = str.length - 1; i2 >= 0; i2--) + if (str.charAt(i2) === "/") + return new Term("/", [new Term(str.substring(0, i2)), new Num(parseInt(str.substring(i2 + 1)), false)]); + } + function gcd(a, b) { + if (b === 0) + return a; + return Math.abs(gcd(b, a % b)); + } + function Var(id) { + this.id = id; + this.ground = false; + } + function Num(value, is_float) { + this.is_float = is_float !== void 0 ? is_float : Math.trunc(value) !== value; + this.value = this.is_float ? value : Math.trunc(value); + this.index = this.value; + this.ground = true; + } + var term_ref = 0; + function Term(id, args, ref) { + term_ref++; + this.ref = ref || term_ref; + this.id = id; + this.args = args || []; + this.indicator = id + "/" + this.args.length; + this.index = this.indicator; + this.ground = true; + for (var i2 = 0; i2 < this.args.length; i2++) { + if (this.args[i2].hasOwnProperty("ground") && this.args[i2].ground === false) { + this.ground = false; + break; + } + } + } + var stream_ref = 0; + function Stream(stream, mode, alias, type, reposition, eof_action) { + this.id = stream_ref++; + this.stream = stream; + this.mode = mode; + this.alias = alias; + this.type = type !== void 0 ? type : "text"; + this.reposition = reposition !== void 0 ? reposition : true; + this.eof_action = eof_action !== void 0 ? eof_action : "eof_code"; + this.position = this.mode === "append" ? "end_of_stream" : 0; + this.output = this.mode === "write" || this.mode === "append"; + this.input = this.mode === "read"; + this.line_position = 0; + this.line_count = 1; + this.char_count = 0; + } + function Substitution(links, attrs) { + links = links || {}; + attrs = attrs || {}; + this.links = links; + this.attrs = attrs; + } + function State(goal, subs, parent) { + subs = subs || new Substitution(); + parent = parent || null; + this.goal = goal; + this.substitution = subs; + this.parent = parent; + } + function Rule(head, body, dynamic) { + this.head = head; + this.body = body; + this.dynamic = dynamic ? dynamic : false; + } + function Session(limit) { + limit = typeof limit === "number" && limit > 0 ? limit : null; + this.rename = 0; + this.modules = {}; + this.modules.user = new Module("user", {}, "all", { + session: this, + dependencies: ["system"] + }); + this.modules.system = pl.modules.system; + this.rules = this.modules.user.rules; + this.total_threads = 0; + this.renamed_variables = {}; + this.public_predicates = this.modules.user.public_predicates; + this.multifile_predicates = this.modules.user.multifile_predicates; + this.limit = limit; + this.streams = { + "user_input": new Stream( + nodejs_flag ? nodejs_user_input : tau_user_input, + "read", + "user_input", + "text", + false, + "reset" + ), + "user_output": new Stream( + nodejs_flag ? nodejs_user_output : tau_user_output, + "append", + "user_output", + "text", + false, + "reset" + ), + "user_error": new Stream( + nodejs_flag ? nodejs_user_error : tau_user_error, + "append", + "user_error", + "text", + false, + "reset" + ) + }; + this.file_system = nodejs_flag ? nodejs_file_system : tau_file_system; + this.standard_input = this.streams["user_input"]; + this.standard_output = this.streams["user_output"]; + this.standard_error = this.streams["user_error"]; + this.current_input = this.streams["user_input"]; + this.current_output = this.streams["user_output"]; + this.working_directory = "/"; + this.format_success = function(state) { + return state.substitution; + }; + this.format_error = function(state) { + return state.goal; + }; + this.flag = { + bounded: pl.flag.bounded.value, + max_integer: pl.flag.max_integer.value, + min_integer: pl.flag.min_integer.value, + integer_rounding_function: pl.flag.integer_rounding_function.value, + char_conversion: pl.flag.char_conversion.value, + debug: pl.flag.debug.value, + max_arity: pl.flag.max_arity.value, + unknown: pl.flag.unknown.value, + double_quotes: pl.flag.double_quotes.value, + occurs_check: pl.flag.occurs_check.value, + dialect: pl.flag.dialect.value, + version_data: pl.flag.version_data.value, + nodejs: pl.flag.nodejs.value, + argv: pl.flag.argv.value + }; + this.__loaded_modules = []; + this.__char_conversion = {}; + this.__operators = { + 1200: { ":-": ["fx", "xfx"], "-->": ["xfx"], "?-": ["fx"] }, + 1150: { "meta_predicate": ["fx"] }, + 1100: { ";": ["xfy"] }, + 1050: { "->": ["xfy"], "*->": ["xfy"] }, + 1e3: { ",": ["xfy"] }, + 900: { "\\+": ["fy"] }, + 700: { + "=": ["xfx"], + "\\=": ["xfx"], + "==": ["xfx"], + "\\==": ["xfx"], + "@<": ["xfx"], + "@=<": ["xfx"], + "@>": ["xfx"], + "@>=": ["xfx"], + "=..": ["xfx"], + "is": ["xfx"], + "=:=": ["xfx"], + "=\\=": ["xfx"], + "<": ["xfx"], + "=<": ["xfx"], + ">": ["xfx"], + ">=": ["xfx"] + }, + 600: { ":": ["xfy"] }, + 500: { "+": ["yfx"], "-": ["yfx"], "/\\": ["yfx"], "\\/": ["yfx"] }, + 400: { + "*": ["yfx"], + "/": ["yfx"], + "//": ["yfx"], + "rem": ["yfx"], + "mod": ["yfx"], + "<<": ["yfx"], + ">>": ["yfx"], + "div": ["yfx"] + }, + 200: { "**": ["xfx"], "^": ["xfy"], "-": ["fy"], "+": ["fy"], "\\": ["fy"] } + }; + this.thread = new Thread(this); + } + function Thread(session) { + this.epoch = Date.now(); + this.session = session; + this.session.total_threads++; + this.format_success = session.format_success; + this.format_error = session.format_error; + this.total_steps = 0; + this.cpu_time = 0; + this.points = []; + this.debugger = false; + this.debugger_states = []; + this.level = new Term("top_level"); + this.current_limit = this.session.limit; + this.has_limit = this.session.limit !== null; + this.warnings = []; + this.__calls = []; + this.__goal_expansion = false; + this.__stacks = {}; + } + function Module(id, rules2, exports2, options) { + options = options === void 0 ? {} : options; + options.public_predicates = options.public_predicates === void 0 ? {} : options.public_predicates; + options.multifile_predicates = options.multifile_predicates === void 0 ? {} : options.multifile_predicates; + options.meta_predicates = options.meta_predicates === void 0 ? {} : options.meta_predicates; + options.session = options.session === void 0 ? null : options.session; + options.dependencies = options.dependencies === void 0 ? [] : options.dependencies; + this.id = id; + this.rules = rules2; + this.indexed_clauses = {}; + this.non_indexable_clauses = {}; + this.public_predicates = options.public_predicates; + this.multifile_predicates = options.multifile_predicates; + this.meta_predicates = options.meta_predicates; + this.src_predicates = {}; + this.dependencies = options.dependencies; + this.exports = exports2; + this.is_library = options.session === null; + this.modules = {}; + if (options.session) { + options.session.modules[id] = this; + for (var i2 = 0; i2 < options.dependencies.length; i2++) { + var lib = options.dependencies[i2]; + if (!options.session.modules.hasOwnProperty(lib)) + options.session.modules[lib] = pl.modules[lib]; + } + } else { + pl.modules[id] = this; + } + if (exports2 !== "all") { + for (var i2 = 0; i2 < exports2.length; i2++) { + this.public_predicates[exports2[i2]] = options.public_predicates.hasOwnProperty(exports2[i2]) && options.public_predicates[exports2[i2]] === true; + } + } + this.update_indices_clauses(); + } + Module.prototype.exports_predicate = function(indicator2) { + return this.exports === "all" || indexOf(this.exports, indicator2) !== -1; + }; + Module.prototype.is_public_predicate = function(indicator2) { + return !this.public_predicates.hasOwnProperty(indicator2) || this.public_predicates[indicator2] === true; + }; + Module.prototype.is_multifile_predicate = function(indicator2) { + return this.multifile_predicates.hasOwnProperty(indicator2) && this.multifile_predicates[indicator2] === true; + }; + Module.prototype.is_meta_predicate = function(indicator2) { + if (this.meta_predicates.hasOwnProperty(indicator2)) + return this.meta_predicates[indicator2]; + return null; + }; + Module.prototype.update_indices_clauses = function() { + this.indexed_clauses = {}; + this.non_indexable_clauses = {}; + for (var indicator2 in this.rules) + this.update_indices_predicate(indicator2); + }; + Module.prototype.update_indices_predicate = function(indicator2) { + this.indexed_clauses[indicator2] = {}; + this.non_indexable_clauses[indicator2] = []; + if (!Array.isArray(this.rules[indicator2])) + return; + for (var i2 = 0; i2 < this.rules[indicator2].length; i2++) { + var clause = this.rules[indicator2][i2]; + this.add_index_predicate(clause); + } + }; + Module.prototype.add_index_predicate = function(clause) { + var indicator2 = clause.head.indicator; + var index = clause.head.args.length > 0 ? clause.head.args[0].index : void 0; + if (index) { + if (!this.indexed_clauses.hasOwnProperty(indicator2)) + this.indexed_clauses[indicator2] = {}; + if (!this.indexed_clauses[indicator2].hasOwnProperty(index)) { + this.indexed_clauses[indicator2][index] = []; + if (this.non_indexable_clauses.hasOwnProperty(indicator2)) + for (var j = 0; j < this.non_indexable_clauses[indicator2].length; j++) + this.indexed_clauses[indicator2][index].push(this.non_indexable_clauses[indicator2][j]); + } + this.indexed_clauses[indicator2][index].push(clause); + } else { + if (!this.non_indexable_clauses.hasOwnProperty(indicator2)) + this.non_indexable_clauses[indicator2] = []; + this.non_indexable_clauses[indicator2].push(clause); + for (var index in this.indexed_clauses[indicator2]) + this.indexed_clauses[indicator2][index].push(clause); + } + }; + Var.prototype.unify = function(obj, occurs_check) { + if (occurs_check && indexOf(obj.variables(), this.id) !== -1 && !pl.type.is_variable(obj)) + return null; + var links = {}; + links[this.id] = obj; + return new Substitution(links); + }; + Num.prototype.unify = function(obj, occurs_check) { + if (pl.type.is_number(obj) && this.value === obj.value && this.is_float === obj.is_float) + return new Substitution(); + return null; + }; + Term.prototype.unify = function(obj, occurs_check) { + if (!pl.type.is_term(obj) && obj.unify !== void 0) { + return obj.unify(this, occurs_check); + } else if (pl.type.is_term(obj) && this.indicator === obj.indicator) { + var subs = new Substitution(); + for (var i2 = 0; i2 < this.args.length; i2++) { + var mgu = pl.unify(this.args[i2].apply(subs), obj.args[i2].apply(subs), occurs_check); + if (mgu === null) + return null; + for (var x in mgu.links) + subs.links[x] = mgu.links[x]; + subs = subs.apply(mgu); + } + return subs; + } + return null; + }; + Stream.prototype.unify = function(obj, _occurs_check) { + if (pl.type.is_stream(obj) && this.id === obj.id) + return new Substitution(); + return null; + }; + Stream.prototype.compare = function(obj) { + if (this.id < obj.id) + return -1; + else if (this.id === obj.id) + return 0; + else + return 1; + }; + Var.prototype.toString = function(options) { + options = options === void 0 ? {} : options; + if (options.variable_names) { + var pointer = options.variable_names; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var head = pointer.args[0]; + if (pl.type.is_term(head) && head.indicator === "=/2" && pl.type.is_variable(head.args[1]) && head.args[1].id === this.id && pl.type.is_atom(head.args[0])) + return head.args[0].id; + pointer = pointer.args[1]; + } + } + return this.id; + }; + Num.prototype.toString = function(_) { + var str = this.value.toString(); + var e = str.indexOf("e"); + if (e !== -1) { + if (str.indexOf(".") !== -1) + return str; + else + return str.replace("e", ".0e"); + } + return this.is_float && indexOf(str, ".") === -1 ? this.value + ".0" : str; + }; + Term.prototype.toString = function(options, priority, from) { + options = !options ? {} : options; + options.quoted = options.quoted === void 0 ? false : options.quoted; + options.ignore_ops = options.ignore_ops === void 0 ? false : options.ignore_ops; + options.numbervars = options.numbervars === void 0 ? false : options.numbervars; + options.variable_names = options.variable_names === void 0 ? false : options.variable_names; + priority = priority === void 0 ? { priority: 1200, class: "", indicator: "" } : priority; + from = from === void 0 ? "" : from; + var arg_priority = { priority: 999, class: "", indicator: "" }; + if (options.numbervars && this.indicator === "$VAR/1" && pl.type.is_integer(this.args[0]) && this.args[0].value >= 0) { + var i2 = this.args[0].value; + var number = Math.floor(i2 / 26); + var letter = i2 % 26; + return "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[letter] + (number !== 0 ? number : ""); + } + switch (this.indicator) { + case "[]/0": + case "{}/0": + case "!/0": + return this.id; + case "{}/1": + if (options.ignore_ops === false) { + return "{" + this.args[0].toString(options) + "}"; + } else { + return "{}(" + this.args[0].toString(options) + ")"; + } + case "./2": + if (options.ignore_ops === false) { + var list = "[" + this.args[0].toString(options, arg_priority); + var pointer = this.args[1]; + while (pointer.indicator === "./2") { + list += "," + pointer.args[0].toString(options, arg_priority); + pointer = pointer.args[1]; + } + if (pointer.indicator !== "[]/0") { + list += "|" + pointer.toString(options, arg_priority); + } + list += "]"; + return list; + } + default: + var id = this.id; + var operator = options.session ? options.session.lookup_operator(this.id, this.args.length) : null; + if (options.session === void 0 || options.ignore_ops || operator === null) { + if (options.quoted && (!/^(!|[a-z][0-9a-zA-Z_]*|[#\$\&\*\+\-\.\/\:\<\=\>\?\@\^\~\\]+)$/.test(id) && id !== "{}" && id !== "[]" || indexOf([".", ",", ";"], id) !== -1 || id.substring(0, 2) === "/*")) + id = "'" + redoEscape(id) + "'"; + if (this.args.length === 0 && is_graphic_token(this.id) && priority.indicator !== "") + return "(" + id + ")"; + return id + (this.args.length > 0 ? "(" + map( + this.args, + function(x) { + return x.toString(options, arg_priority); + } + ).join(",") + ")" : ""); + } else { + var priority_op = parseInt(operator.priority); + var priority_arg = parseInt(priority.priority); + var cond = priority_op > priority_arg || priority_op === priority_arg && (operator.class === "xfx" || operator.class === "xfy" && this.indicator !== priority.indicator || operator.class === "yfx" && this.indicator !== priority.indicator || this.indicator === priority.indicator && operator.class === "yfx" && from === "right" || this.indicator === priority.indicator && operator.class === "xfy" && from === "left" || this.indicator === priority.indicator && operator.class === "xf" && from === "left" || this.indicator === priority.indicator && operator.class === "fx" && from === "right"); + operator.indicator = this.indicator; + var lpar = cond ? "(" : ""; + var rpar = cond ? ")" : ""; + var space = !(is_graphic_token(this.id) || this.id === "," || this.id === ";") || operator.class.length === 2 || operator.class.length === 3 && pl.type.is_number(this.args[1]) && this.args[1].value < 0 ? " " : ""; + if (this.args.length === 0) { + return lpar + this.id + rpar; + } else if (["fy", "fx"].indexOf(operator.class) !== -1) { + return lpar + id + space + this.args[0].toString(options, operator, "right") + rpar; + } else if (["yf", "xf"].indexOf(operator.class) !== -1) { + return lpar + this.args[0].toString(options, operator, "left") + space + id + rpar; + } else { + return lpar + this.args[0].toString(options, operator, "left") + space + this.id + space + this.args[1].toString(options, operator, "right") + rpar; + } + } + } + }; + Stream.prototype.toString = function(_) { + return "(" + this.id + ")"; + }; + Substitution.prototype.toString = function(options) { + var str = "{"; + for (var link in this.links) { + if (!this.links.hasOwnProperty(link)) + continue; + if (str !== "{") { + str += ", "; + } + str += link + "/" + this.links[link].toString(options); + } + str += "}"; + return str; + }; + State.prototype.toString = function(options) { + if (this.goal === null) { + return "<" + this.substitution.toString(options) + ">"; + } else { + return "<" + this.goal.toString(options) + ", " + this.substitution.toString(options) + ">"; + } + }; + Rule.prototype.toString = function(options) { + if (!this.body) { + return this.head.toString(options) + "."; + } else { + return this.head.toString(options, 1200, "left") + " :- " + this.body.toString(options, 1200, "right") + "."; + } + }; + Session.prototype.toString = function(options) { + var str = ""; + for (var prop in this.modules) { + if (this.modules.hasOwnProperty(prop) && this.modules[prop].is_library) + str += ":- use_module(library(" + this.modules[prop] + ")).\n"; + } + str += "\n"; + for (var key in this.modules.user.rules) { + if (!this.modules.user.rules.hasOwnProperty(key)) + continue; + for (i = 0; i < this.modules.user.rules[key].length; i++) { + str += this.modules.user.rules[key][i].toString(options); + str += "\n"; + } + } + return str; + }; + Var.prototype.clone = function() { + return new Var(this.id); + }; + Num.prototype.clone = function() { + return new Num(this.value, this.is_float); + }; + Term.prototype.clone = function() { + var term = new Term(this.id, map(this.args, function(arg) { + return arg.clone(); + })); + if (this.definition_module) + term.definition_module = this.definition_module; + return term; + }; + Stream.prototype.clone = function() { + return new Stream(this.stream, this.mode, this.alias, this.type, this.reposition, this.eof_action); + }; + Substitution.prototype.clone = function() { + var links = {}; + var attrs = {}; + for (var link in this.links) { + if (!this.links.hasOwnProperty(link)) + continue; + links[link] = this.links[link].clone(); + } + for (var attr in this.attrs) { + if (!this.attrs.hasOwnProperty(attrs)) + continue; + attrs[attr] = {}; + for (var m in this.attrs[attr]) { + if (!this.attrs[attr].hasOwnProperty(m)) + continue; + attrs[attr][m] = this.attrs[attr][m].clone(); + } + } + return new Substitution(links, attrs); + }; + State.prototype.clone = function() { + return new State(this.goal.clone(), this.substitution.clone(), this.parent); + }; + Rule.prototype.clone = function() { + return new Rule(this.head.clone(), this.body !== null ? this.body.clone() : null); + }; + Var.prototype.equals = function(obj) { + return pl.type.is_variable(obj) && this.id === obj.id; + }; + Num.prototype.equals = function(obj) { + return pl.type.is_number(obj) && this.value === obj.value && this.is_float === obj.is_float; + }; + Term.prototype.equals = function(obj) { + if (!pl.type.is_term(obj) || this.indicator !== obj.indicator) { + return false; + } + for (var i2 = 0; i2 < this.args.length; i2++) { + if (!this.args[i2].equals(obj.args[i2])) { + return false; + } + } + return true; + }; + Stream.prototype.equals = function(obj) { + return pl.type.is_stream(obj) && this.id === obj.id; + }; + Substitution.prototype.equals = function(obj) { + var link; + if (!pl.type.is_substitution(obj)) { + return false; + } + for (link in this.links) { + if (!this.links.hasOwnProperty(link)) + continue; + if (!obj.links[link] || !this.links[link].equals(obj.links[link])) { + return false; + } + } + for (link in obj.links) { + if (!obj.links.hasOwnProperty(link)) + continue; + if (!this.links[link]) { + return false; + } + } + return true; + }; + State.prototype.equals = function(obj) { + return pl.type.is_state(obj) && this.goal.equals(obj.goal) && this.substitution.equals(obj.substitution) && this.parent === obj.parent; + }; + Rule.prototype.equals = function(obj) { + return pl.type.is_rule(obj) && this.head.equals(obj.head) && (this.body === null && obj.body === null || this.body !== null && this.body.equals(obj.body)); + }; + Var.prototype.rename = function(thread) { + return thread.get_free_variable(this); + }; + Num.prototype.rename = function(_) { + return this; + }; + Term.prototype.rename = function(thread) { + if (this.ground) + return new Term(this.id, this.args); + if (this.indicator === "./2") { + var arr = []; + var pointer = this; + while (pointer.indicator === "./2" && !pointer.ground) { + var app = pointer.args[0].rename(thread); + arr.push(app); + pointer = pointer.args[1]; + } + var list = pointer.rename(thread); + for (var i2 = arr.length - 1; i2 >= 0; i2--) + list = new Term(".", [arr[i2], list]); + return list; + } + var args = []; + for (var i2 = 0; i2 < this.args.length; i2++) { + var app = this.args[i2].rename(thread); + args.push(app); + } + return new Term(this.id, args); + }; + Stream.prototype.rename = function(thread) { + return this; + }; + Rule.prototype.rename = function(thread) { + return new Rule(this.head.rename(thread), this.body !== null ? this.body.rename(thread) : null); + }; + Var.prototype.is_rename = function(obj, links) { + links = links || {}; + if (!pl.type.is_variable(obj) || links.hasOwnProperty(this.id) && links[this.id] !== obj.id || links.hasOwnProperty(obj.id) && links[obj.id] !== this.id) + return false; + links[this.id] = obj.id; + links[obj.id] = this.id; + return true; + }; + Num.prototype.is_rename = function(obj, _links) { + return this.equals(obj); + }; + Term.prototype.is_rename = function(obj, links) { + links = links || {}; + if (!pl.type.is_term(obj) || this.indicator !== obj.indicator) + return false; + for (var i2 = 0; i2 < this.args.length; i2++) { + if (!pl.is_rename(this.args[i2], obj.args[i2], links)) + return false; + } + return true; + }; + Stream.prototype.is_rename = function(obj, _links) { + return this.equals(obj); + }; + Var.prototype.variables = function() { + return [this.id]; + }; + Num.prototype.variables = function() { + return []; + }; + Term.prototype.variables = function() { + if (this.ground) + return []; + return [].concat.apply([], map(this.args, function(arg) { + return arg.variables(); + })); + }; + Stream.prototype.variables = function() { + return []; + }; + Rule.prototype.variables = function() { + if (this.body === null) { + return this.head.variables(); + } else { + return this.head.variables().concat(this.body.variables()); + } + }; + Var.prototype.apply = function(subs) { + if (subs.lookup(this.id)) { + return subs.lookup(this.id); + } + return this; + }; + Num.prototype.apply = function(_) { + return this; + }; + Term.prototype.apply = function(subs) { + if (this.ground) + return this; + if (this.indicator === "./2") { + var arr = []; + var pointer = this; + while (pointer.indicator === "./2" && !pointer.ground) { + var app = pointer.args[0].apply(subs); + arr.push(app); + pointer = pointer.args[1]; + } + var list = pointer.apply(subs); + for (var i2 = arr.length - 1; i2 >= 0; i2--) + list = new Term(".", [arr[i2], list]); + return list; + } + var args = []; + for (var i2 = 0; i2 < this.args.length; i2++) { + var app = this.args[i2].apply(subs); + args.push(app); + } + return new Term(this.id, args, this.ref); + }; + Stream.prototype.apply = function(_) { + return this; + }; + Rule.prototype.apply = function(subs) { + return new Rule(this.head.apply(subs), this.body !== null ? this.body.apply(subs) : null); + }; + Substitution.prototype.apply = function(subs) { + var link, links = {}, attr, attrs = {}, m; + for (link in this.links) { + if (!this.links.hasOwnProperty(link)) + continue; + links[link] = this.links[link].apply(subs); + } + for (attr in this.attrs) { + if (!this.attrs.hasOwnProperty(attr)) + continue; + attrs[attr] = {}; + for (m in this.attrs[attr]) { + if (!this.attrs[attr].hasOwnProperty(m)) + continue; + attrs[attr][m] = this.attrs[attr][m].apply(subs); + } + } + return new Substitution(links, attrs); + }; + Term.prototype.select = function() { + var pointer = this; + while (pl.type.is_term(pointer) && pointer.indicator === ",/2") + pointer = pointer.args[0]; + return pointer; + }; + Term.prototype.replace = function(expr) { + if (this.indicator === ",/2") { + if (this.args[0].indicator === ",/2") { + return new Term(",", [this.args[0].replace(expr), this.args[1]]); + } else { + return expr === null ? this.args[1] : new Term(",", [expr, this.args[1]]); + } + } else { + return expr; + } + }; + Term.prototype.search = function(expr) { + if (this == expr || this.ref === expr.ref) + return true; + for (var i2 = 0; i2 < this.args.length; i2++) + if (pl.type.is_term(this.args[i2]) && this.args[i2].search(expr)) + return true; + return false; + }; + Session.prototype.push_global_stack = function(stack, value) { + return this.thread.push_global_stack(stack, value); + }; + Thread.prototype.push_global_stack = function(stack, value) { + if (!this.__stacks.hasOwnProperty(stack)) + this.__stacks[stack] = []; + this.__stacks[stack].push(value); + }; + Session.prototype.flush_global_stack = function(stack, tail) { + return this.thread.push_global_stack(stack, tail); + }; + Thread.prototype.flush_global_stack = function(stack, tail) { + var list = tail || new Term("[]", []); + if (this.__stacks.hasOwnProperty(stack)) { + while (this.__stacks[stack].length > 0) + list = new Term(".", [this.__stacks[stack].pop(), list]); + delete this.__stacks[stack]; + } + return list; + }; + Session.prototype.setMaxInferences = function(max) { + this.limit = typeof max === "number" && max > 0 ? max : null; + }; + Thread.prototype.setMaxInferences = function(max) { + this.session.setMaxInferences(max); + this.current_limit = this.session.limit; + this.has_limit = this.session.limit !== null; + }; + Session.prototype.format_answer = function(answer, options) { + return this.thread.format_answer(answer, options); + }; + Thread.prototype.format_answer = function(answer, options) { + return pl.format_answer(answer, this, options); + }; + Session.prototype.get_current_input = function() { + return this.current_input; + }; + Thread.prototype.get_current_input = function() { + return this.session.get_current_input(); + }; + Session.prototype.get_current_output = function() { + return this.current_output; + }; + Thread.prototype.get_current_output = function() { + return this.session.get_current_output(); + }; + Session.prototype.set_current_input = function(input) { + this.current_input = input; + }; + Thread.prototype.set_current_input = function(input) { + return this.session.set_current_input(input); + }; + Session.prototype.set_current_output = function(output) { + this.current_output = output; + }; + Thread.prototype.set_current_output = function(output) { + return this.session.set_current_output(output); + }; + Session.prototype.get_stream_by_alias = function(alias) { + return this.streams[alias]; + }; + Thread.prototype.get_stream_by_alias = function(alias) { + return this.session.get_stream_by_alias(alias); + }; + Session.prototype.file_system_open = function(path2, type, mode) { + if (this.get_flag("nodejs").indicator === "false/0") + path2 = this.absolute_file_name(path2); + return this.file_system.open(path2, type, mode); + }; + Thread.prototype.file_system_open = function(path2, type, mode) { + return this.session.file_system_open(path2, type, mode); + }; + Session.prototype.absolute_file_name = function(filename) { + var absolute; + if (this.get_flag("nodejs").indicator === "true/0") { + var path2 = require("path"); + absolute = filename; + for (var prop in process.env) { + if (!process.env.hasOwnProperty(prop)) + continue; + absolute = absolute.replace(new RegExp("\\$" + prop, "g"), process.env[prop]); + } + return path2.resolve(absolute); + } else { + var cwd = this.working_directory; + if (filename[0] === "/") + absolute = filename; + else + absolute = cwd + (cwd[cwd.length - 1] === "/" ? filename : "/" + filename); + absolute = absolute.replace(/\/\.\//g, "/"); + var dirs = absolute.split("/"); + var dirs2 = []; + for (var i2 = 0; i2 < dirs.length; i2++) { + if (dirs[i2] !== "..") { + dirs2.push(dirs[i2]); + } else { + if (dirs2.length !== 0) + dirs2.pop(); + } + } + absolute = dirs2.join("/").replace(/\/\.$/, "/"); + } + return absolute; + }; + Thread.prototype.absolute_file_name = function(path2, cwd) { + return this.session.absolute_file_name(path2, cwd); + }; + Session.prototype.get_char_conversion = function(char) { + return this.__char_conversion[char] || char; + }; + Thread.prototype.get_char_conversion = function(char) { + return this.session.get_char_conversion(char); + }; + Session.prototype.parse = function(string) { + return this.thread.parse(string); + }; + Thread.prototype.parse = function(string) { + var tokenizer = new Tokenizer(this); + tokenizer.new_text(string); + var tokens = tokenizer.get_tokens(); + if (tokens === null) + return false; + var expr = parseExpr(this, tokens, 0, this.__get_max_priority(), false); + if (expr.len !== tokens.length) + return false; + return { value: expr.value, expr, tokens }; + }; + Session.prototype.get_flag = function(flag) { + return this.flag[flag]; + }; + Thread.prototype.get_flag = function(flag) { + return this.session.get_flag(flag); + }; + Session.prototype.add_rule = function(rule, options) { + return this.thread.add_rule(rule, options); + }; + Thread.prototype.add_rule = function(rule, options) { + options = options ? options : {}; + options.from = options.from ? options.from : "$tau-js"; + var module_id, get_module; + if (pl.type.is_term(rule.head) && rule.head.indicator === ":/2") { + if (!pl.type.is_atom(rule.head.args[0])) { + this.throw_warning(pl.error.type("module", rule.head.args[0], "top_level/0")); + return; + } + module_id = rule.head.args[0].id; + rule.head = rule.head.args[1]; + } + if (module_id) { + get_module = this.session.modules[module_id]; + if (!pl.type.is_module(get_module)) { + get_module = new Module(module_id, {}, "all", { session: this.session }); + this.session.modules[module_id] = get_module; + } + } else { + get_module = this.session.modules[options.context_module]; + } + get_module.src_predicates[rule.head.indicator] = options.from; + if (!get_module.rules.hasOwnProperty(rule.head.indicator)) { + get_module.rules[rule.head.indicator] = []; + } + get_module.rules[rule.head.indicator].push(rule); + if (!get_module.public_predicates.hasOwnProperty(rule.head.indicator)) + get_module.public_predicates[rule.head.indicator] = false; + get_module.add_index_predicate(rule); + return true; + }; + Session.prototype.run_directive = function(directive, options) { + return this.thread.run_directive(directive, options); + }; + Thread.prototype.run_directive = function(directive, options) { + if (pl.type.is_directive(directive)) { + if (pl.directive[directive.indicator]) + return pl.directive[directive.indicator](this, directive, options); + else + return pl.directive[directive.id + "/*"](this, directive, options); + } + return false; + }; + Session.prototype.__get_max_priority = function() { + return "1200"; + }; + Thread.prototype.__get_max_priority = function() { + return this.session.__get_max_priority(); + }; + Session.prototype.__get_next_priority = function(priority) { + var max = 0; + priority = parseInt(priority); + for (var key in this.__operators) { + if (!this.__operators.hasOwnProperty(key)) + continue; + var n = parseInt(key); + if (n > max && n < priority) + max = n; + } + return max.toString(); + }; + Thread.prototype.__get_next_priority = function(priority) { + return this.session.__get_next_priority(priority); + }; + Session.prototype.__lookup_operator_classes = function(priority, operator) { + if (this.__operators.hasOwnProperty(priority) && this.__operators[priority][operator] instanceof Array) { + return this.__operators[priority][operator] || false; + } + return false; + }; + Thread.prototype.__lookup_operator_classes = function(priority, operator) { + return this.session.__lookup_operator_classes(priority, operator); + }; + Session.prototype.lookup_operator = function(name, arity) { + for (var p in this.__operators) + if (this.__operators[p][name]) { + for (var i2 = 0; i2 < this.__operators[p][name].length; i2++) + if (this.__operators[p][name][i2].length === arity + 1) + return { priority: p, class: this.__operators[p][name][i2] }; + } + return null; + }; + Thread.prototype.lookup_operator = function(name, arity) { + return this.session.lookup_operator(name, arity); + }; + Session.prototype.throw_warning = function(warning) { + this.thread.throw_warning(warning); + }; + Thread.prototype.throw_warning = function(warning) { + this.warnings.push(warning); + }; + Session.prototype.get_warnings = function() { + return this.thread.get_warnings(); + }; + Thread.prototype.get_warnings = function() { + return this.warnings; + }; + Session.prototype.add_goal = function(goal, unique) { + this.thread.add_goal(goal, unique); + }; + Thread.prototype.add_goal = function(goal, unique, parent) { + parent = parent ? parent : null; + if (unique === true) + this.points = []; + var vars = goal.variables(); + var links = {}; + for (var i2 = 0; i2 < vars.length; i2++) + links[vars[i2]] = new Var(vars[i2]); + this.points.push(new State(goal, new Substitution(links), parent)); + }; + Session.prototype.consult = function(program, options) { + return this.thread.consult(program, options); + }; + Thread.prototype.consult = function(program, options) { + var string = "", success = false; + var opts = {}; + var callback = typeof options === "function" ? options : function() { + }; + options = options === void 0 || typeof options === "function" ? {} : options; + opts.context_module = options.context_module === void 0 ? "user" : options.context_module; + opts.text = options.text === void 0 ? true : options.text; + opts.html = options.html === void 0 ? true : options.html; + opts.url = options.url === void 0 ? true : options.url; + opts.file = options.file === void 0 ? true : options.file; + opts.script = options.script === void 0 ? true : options.script; + opts.success = options.success === void 0 ? callback : options.success; + opts.error = options.error === void 0 ? callback : options.error; + if (typeof program === "string") { + string = program; + if (opts.script && this.get_flag("nodejs").indicator === "false/0" && program != "" && document.getElementById(string)) { + var script = document.getElementById(string); + var type = script.getAttribute("type"); + if (type !== null && type.replace(/ /g, "").toLowerCase() === "text/prolog") { + string = script.text; + success = true; + } + } + if (!success && opts.file && this.get_flag("nodejs").indicator === "true/0") { + var fs2 = require("fs"); + var thread = this; + fs2.readFile(program, function(error, data) { + if (error) { + opts.file = false; + thread.consult(program, opts); + } else { + parseProgram(thread, data.toString(), opts); + } + }); + return; + } + if (!success && this.get_flag("nodejs").indicator === "false/0" && opts.url && program !== "" && !/\s/.test(program)) { + try { + var xhttp = new XMLHttpRequest(); + var thread = this; + xhttp.onreadystatechange = function() { + if (this.readyState == 4) { + if (this.status == 200) { + string = xhttp.responseText; + success = true; + parseProgram(thread, string, opts); + } else { + opts.url = false; + thread.consult(program, opts); + } + } + }; + xhttp.open("GET", program, true); + xhttp.send(); + return; + } catch (ex) { + opts.error(ex); + return; + } + } + if (!success && opts.text) { + success = true; + } + } else if (opts.html && program.nodeName) { + switch (program.nodeName.toLowerCase()) { + case "input": + case "textarea": + string = program.value; + success = true; + break; + default: + string = program.innerHTML; + success = true; + break; + } + } else { + opts.error(pl.error.existence("source_sink", new Term(string), "top_level/0")); + } + this.warnings = []; + parseProgram(this, string, opts); + }; + Session.prototype.query = function(string, options) { + return this.thread.query(string, options); + }; + Thread.prototype.query = function(string, options) { + this.points = []; + this.debugger_states = []; + this.level = new Term("top_level"); + return parseQuery(this, string, options); + }; + Session.prototype.head_point = function() { + return this.thread.head_point(); + }; + Thread.prototype.head_point = function() { + return this.points[this.points.length - 1]; + }; + Session.prototype.get_free_variable = function(variable) { + return this.thread.get_free_variable(variable); + }; + Thread.prototype.get_free_variable = function(variable) { + var variables = []; + if (variable.id === "_" || this.session.renamed_variables[variable.id] === void 0) { + this.session.rename++; + if (this.current_point) + variables = this.current_point.substitution.domain(); + while (indexOf(variables, pl.format_variable(this.session.rename, variable.id)) !== -1) { + this.session.rename++; + } + if (variable.id === "_") { + return new Var(pl.format_variable(this.session.rename, variable.id)); + } else { + this.session.renamed_variables[variable.id] = pl.format_variable(this.session.rename, variable.id); + } + } + return new Var(this.session.renamed_variables[variable.id]); + }; + Session.prototype.next_free_variable = function() { + return this.thread.next_free_variable(); + }; + Thread.prototype.next_free_variable = function() { + this.session.rename++; + var variables = []; + if (this.current_point) + variables = this.current_point.substitution.domain(); + while (indexOf(variables, pl.format_variable(this.session.rename)) !== -1) { + this.session.rename++; + } + return new Var(pl.format_variable(this.session.rename)); + }; + Session.prototype.is_public_predicate = function(indicator2, module_id) { + module_id = module_id === void 0 ? "user" : module_id; + return pl.type.is_module(this.modules[module_id]) && this.modules[module_id].is_public_predicate(indicator2); + }; + Thread.prototype.is_public_predicate = function(indicator2, module_id) { + return this.session.is_public_predicate(indicator2, module_id); + }; + Session.prototype.is_multifile_predicate = function(indicator2, module_id) { + module_id = module_id === void 0 ? "user" : module_id; + return pl.type.is_module(this.modules[module_id]) && this.modules[module_id].is_multifile_predicate(indicator2); + }; + Thread.prototype.is_multifile_predicate = function(indicator2, module_id) { + return this.session.is_multifile_predicate(indicator2, module_id); + }; + Session.prototype.is_meta_predicate = function(indicator2, module_id) { + module_id = module_id === void 0 ? "user" : module_id; + if (pl.type.is_module(this.modules[module_id])) + return this.modules[module_id].is_meta_predicate(indicator2); + return null; + }; + Thread.prototype.is_meta_predicate = function(indicator2, module_id) { + return this.session.is_meta_predicate(indicator2, module_id); + }; + Session.prototype.prepend = function(states) { + return this.thread.prepend(states); + }; + Thread.prototype.prepend = function(states) { + for (var i2 = states.length - 1; i2 >= 0; i2--) + this.points.push(states[i2]); + }; + Session.prototype.success = function(point, parent) { + return this.thread.success(point, parent); + }; + Thread.prototype.success = function(point, parent) { + var parent = typeof parent === "undefined" ? point : parent; + this.prepend([new State(point.goal.replace(null), point.substitution, parent)]); + }; + Session.prototype.throw_error = function(error) { + return this.thread.throw_error(error); + }; + Thread.prototype.throw_error = function(error) { + if (pl.type.is_variable(error)) + error = pl.error.instantiation(this.level.indicator); + var state = new State( + new Term("throw", [error]), + new Substitution(), + null + ); + state.error = true; + this.prepend([state]); + }; + Session.prototype.lookup_module = function(atom, context_module) { + return this.thread.lookup_module(atom, context_module); + }; + Thread.prototype.lookup_module = function(atom, context_module) { + var get_module = this.session.modules[context_module]; + if (!pl.type.is_module(get_module)) + get_module = this.session.modules.user; + if (get_module.rules.hasOwnProperty(atom.indicator) && (get_module.exports_predicate(atom.indicator) || get_module.rules.hasOwnProperty(this.level.indicator) || context_module === get_module.id)) + return get_module; + get_module.modules.system = pl.modules.system; + get_module.modules.user = this.session.modules.user; + for (var prop in get_module.modules) { + if (!this.session.modules.hasOwnProperty(prop)) + continue; + var get_module = this.session.modules[prop]; + if (get_module.rules.hasOwnProperty(atom.indicator) && (get_module.exports_predicate(atom.indicator) || get_module.rules.hasOwnProperty(this.level.indicator) || context_module === get_module.id)) + return get_module; + } + return null; + }; + Session.prototype.expand_meta_predicate = function(atom, definition_module, context_module) { + return this.thread.expand_meta_predicate(atom, definition_module, context_module); + }; + Thread.prototype.expand_meta_predicate = function(atom, definition_module, context_module) { + var get_module = this.session.modules[definition_module]; + if (!get_module) + return; + var meta = get_module.is_meta_predicate(atom.indicator); + if (!meta) + return; + for (var i2 = 0; i2 < meta.args.length; i2++) { + if (pl.type.is_integer(meta.args[i2]) || pl.type.is_atom(meta.args[i2]) && indexOf([":"], meta.args[i2].id) !== -1) { + if (!pl.type.is_term(atom.args[i2]) || atom.args[i2].indicator !== ":/2") { + atom.args[i2] = new Term(":", [new Term(context_module), atom.args[i2]]); + } + } else if (pl.type.is_atom(meta.args[i2]) && meta.args[i2].id === "^") { + var pointer_last = atom; + var pointer_index = i2; + var pointer = atom.args[i2]; + while (pl.type.is_term(pointer) && pointer.indicator === "^/2") { + pointer_last = pointer; + pointer_index = 1; + pointer = pointer.args[1]; + } + if (!pl.type.is_term(pointer) || pointer.indicator !== ":/2") { + pointer_last.args[pointer_index] = new Term(":", [new Term(context_module), pointer]); + } + } + } + }; + Session.prototype.step = function() { + return this.thread.step(); + }; + Thread.prototype.step = function() { + if (this.points.length === 0) { + return; + } + var asyn = false; + var point = this.points.pop(); + this.current_point = point; + if (this.debugger) + this.debugger_states.push(point); + var atom = pl.type.is_term(point.goal) ? point.goal.select() : point.goal; + if (pl.type.is_term(atom) && (atom.indicator !== ":/2" || pl.type.is_term(atom.args[1]))) { + var context_module = null; + var states = []; + if (atom !== null) { + this.total_steps++; + var level = point; + while (level.parent !== null && level.parent.goal.search(atom)) + level = level.parent; + if (level.parent === null) { + this.level = new Term("top_level"); + } else { + this.level = level.parent.goal.select(); + if (this.level.indicator === ":/2") + this.level = this.level.args[1]; + } + if (pl.type.is_term(atom) && atom.indicator === ":/2") { + context_module = atom.args[0]; + atom = atom.args[1]; + if (!pl.type.is_atom(context_module)) { + this.throw_error(pl.error.type("module", context_module, this.level.indicator)); + return; + } + context_module = context_module.id; + } else { + if (this.level.definition_module) { + context_module = this.level.definition_module; + } else { + context_module = "user"; + } + } + atom.context_module = context_module; + if (atom.indicator === ",/2") { + this.prepend([new State( + point.goal.replace(new Term(",", [ + new Term(":", [new Term(context_module), atom.args[0]]), + new Term(":", [new Term(context_module), atom.args[1]]) + ])), + point.substitution, + point + )]); + return; + } + this.__call_indicator = atom.indicator; + var get_module = this.lookup_module(atom, context_module); + atom.definition_module = pl.type.is_module(get_module) ? get_module.id : "user"; + this.expand_meta_predicate(atom, atom.definition_module, context_module); + var clauses = null; + if (get_module && atom.args.length > 0 && atom.args[0].index && get_module.indexed_clauses.hasOwnProperty(atom.indicator) && get_module.indexed_clauses[atom.indicator].hasOwnProperty(atom.args[0].index)) + clauses = get_module.indexed_clauses[atom.indicator][atom.args[0].index]; + else + clauses = get_module === null ? null : get_module.rules[atom.indicator]; + if (clauses === null) { + if (!this.session.modules.user.rules.hasOwnProperty(atom.indicator)) { + if (this.get_flag("unknown").id === "error") { + this.throw_error(pl.error.existence("procedure", atom.indicator, this.level.indicator)); + } else if (this.get_flag("unknown").id === "warning") { + this.throw_warning("unknown procedure " + atom.indicator + " (from " + this.level.indicator + ")"); + } + } + } else if (clauses instanceof Function) { + asyn = clauses(this, point, atom); + } else { + if (this.__goal_expansion && atom.indicator === "goal_expansion/2") + clauses = clauses.concat(pl.builtin.rules["goal_expansion/2"]); + for (var i2 = 0; i2 < clauses.length; i2++) { + this.session.renamed_variables = {}; + var clause = clauses[i2].rename(this); + var occurs_check = this.get_flag("occurs_check").indicator === "true/0"; + var mgu = pl.unify(atom, clause.head, occurs_check); + if (mgu !== null) { + var state = new State(); + state.goal = point.goal.replace(clause.body); + if (state.goal !== null) + state.goal = state.goal.apply(mgu); + state.substitution = point.substitution.apply(mgu); + state.parent = point; + states.push(state); + } + } + this.prepend(states); + } + } + } else { + var term = pl.type.is_term(atom) && atom.indicator === ":/2" ? atom.args[1] : atom; + if (pl.type.is_variable(term)) + this.throw_error(pl.error.instantiation(this.level.indicator)); + else + this.throw_error(pl.error.type("callable", term, this.level.indicator)); + } + return asyn; + }; + Session.prototype.answer = function(options) { + return this.thread.answer(options); + }; + Thread.prototype.answer = function(options) { + var opts = {}; + options = options || function() { + }; + if (typeof options === "function") { + opts = { + success: options, + error: options, + fail: options, + limit: options + }; + } else { + opts.success = options.success === void 0 ? function() { + } : options.success; + opts.error = options.error === void 0 ? function() { + } : options.error; + opts.fail = options.fail === void 0 ? function() { + } : options.fail; + opts.limit = options.limit === void 0 ? function() { + } : options.limit; + } + this.__calls.push(opts); + if (this.__calls.length > 1) { + return; + } + this.again(); + }; + Session.prototype.answers = function(callback, max, after) { + return this.thread.answers(callback, max, after); + }; + Thread.prototype.answers = function(callback, max, after) { + var answers = max === void 0 ? 1e3 : max; + var thread = this; + if (answers <= 0) { + if (after) + after(); + return; + } + this.answer(function(answer) { + callback(answer); + if (answer !== false) { + setTimeout(function() { + thread.answers(callback, answers - 1, after); + }, 0); + } else if (after) { + after(); + } + }); + }; + Session.prototype.again = function(reset_limit) { + return this.thread.again(reset_limit); + }; + Thread.prototype.again = function(reset_limit) { + while (this.__calls.length > 0) { + this.warnings = []; + if (reset_limit !== false) + this.current_limit = this.session.limit; + while ((!this.has_limit || this.current_limit > 0) && this.points.length > 0 && this.head_point().goal !== null && !pl.type.is_error_state(this.head_point())) { + if (this.has_limit) + this.current_limit--; + var t0 = Date.now(); + var asyn = this.step(); + var t1 = Date.now(); + this.cpu_time += t1 - t0; + if (asyn === true) + return; + } + var call = this.__calls.shift(); + if (this.has_limit && this.current_limit <= 0) { + (function(call2) { + return setTimeout(function() { + call2.limit(null); + }, 0); + })(call); + } else if (this.points.length === 0) { + (function(call2) { + return setTimeout(function() { + call2.fail(false); + }, 0); + })(call); + } else if (pl.type.is_error(this.head_point().goal)) { + var error = this.format_error(this.points.pop()); + this.points = []; + (function(error2, call2) { + return setTimeout(function() { + call2.error(error2); + }, 0); + })(error, call); + } else { + if (this.debugger) + this.debugger_states.push(this.head_point()); + var answer = this.format_success(this.points.pop()); + (function(answer2, call2) { + return setTimeout(function() { + call2.success(answer2); + }, 0); + })(answer, call); + } + } + }; + Session.prototype.unfold = function(rule) { + if (rule.body === null) + return false; + var head = rule.head; + var body = rule.body; + var atom = body.select(); + var thread = new Thread(this); + var unfolded = []; + thread.add_goal(atom); + thread.step(); + for (var i2 = thread.points.length - 1; i2 >= 0; i2--) { + var point = thread.points[i2]; + var head2 = head.apply(point.substitution); + var body2 = body.replace(point.goal); + if (body2 !== null) + body2 = body2.apply(point.substitution); + unfolded.push(new Rule(head2, body2)); + } + var rules2 = this.modules.user.rules[head.indicator]; + var index = indexOf(rules2, rule); + if (unfolded.length > 0 && index !== -1) { + rules2.splice.apply(rules2, [index, 1].concat(unfolded)); + return true; + } + return false; + }; + Thread.prototype.unfold = function(rule) { + return this.session.unfold(rule); + }; + Var.prototype.interpret = function(thread) { + return pl.error.instantiation(thread.level.indicator); + }; + Num.prototype.interpret = function(thread) { + return this; + }; + Term.prototype.interpret = function(thread) { + if (pl.type.is_unitary_list(this)) { + return this.args[0].interpret(thread); + } else { + return pl.operate(thread, this); + } + }; + Var.prototype.compare = function(obj) { + if (this.id < obj.id) { + return -1; + } else if (this.id > obj.id) { + return 1; + } else { + return 0; + } + }; + Num.prototype.compare = function(obj) { + if (this.value === obj.value && this.is_float === obj.is_float) { + return 0; + } else if (this.value < obj.value || this.value === obj.value && this.is_float && !obj.is_float) { + return -1; + } else if (this.value > obj.value) { + return 1; + } + }; + Term.prototype.compare = function(obj) { + if (this.args.length < obj.args.length || this.args.length === obj.args.length && this.id < obj.id) { + return -1; + } else if (this.args.length > obj.args.length || this.args.length === obj.args.length && this.id > obj.id) { + return 1; + } else { + for (var i2 = 0; i2 < this.args.length; i2++) { + var arg = pl.compare(this.args[i2], obj.args[i2]); + if (arg !== 0) { + return arg; + } + } + return 0; + } + }; + Substitution.prototype.lookup = function(variable) { + if (this.links[variable]) { + return this.links[variable]; + } else { + return null; + } + }; + Substitution.prototype.filter = function(predicate) { + var links = {}; + for (var id in this.links) { + if (!this.links.hasOwnProperty(id)) + continue; + var value = this.links[id]; + if (predicate(id, value)) { + links[id] = value; + } + } + return new Substitution(links, this.attrs); + }; + Substitution.prototype.exclude = function(variables) { + var links = {}; + for (var variable in this.links) { + if (!this.links.hasOwnProperty(variable)) + continue; + if (indexOf(variables, variable) === -1) { + links[variable] = this.links[variable]; + } + } + return new Substitution(links, this.attrs); + }; + Substitution.prototype.add = function(variable, value) { + this.links[variable] = value; + }; + Substitution.prototype.domain = function(plain) { + var f = plain === true ? function(x2) { + return x2; + } : function(x2) { + return new Var(x2); + }; + var vars = []; + for (var x in this.links) + vars.push(f(x)); + return vars; + }; + Substitution.prototype.get_attribute = function(variable, module3) { + if (this.attrs[variable]) + return this.attrs[variable][module3]; + }; + Substitution.prototype.set_attribute = function(variable, module3, value) { + var subs = new Substitution(this.links); + for (var v in this.attrs) { + if (v === variable) { + subs.attrs[v] = {}; + for (var m in this.attrs[v]) { + subs.attrs[v][m] = this.attrs[v][m]; + } + } else { + subs.attrs[v] = this.attrs[v]; + } + } + if (!subs.attrs[variable]) { + subs.attrs[variable] = {}; + } + subs.attrs[variable][module3] = value; + return subs; + }; + Substitution.prototype.has_attributes = function(variable) { + return this.attrs[variable] && this.attrs[variable] !== {}; + }; + Var.prototype.compile = function() { + return 'new pl.type.Var("' + this.id.toString() + '")'; + }; + Num.prototype.compile = function() { + return "new pl.type.Num(" + this.value.toString() + ", " + this.is_float.toString() + ")"; + }; + Term.prototype.compile = function() { + return 'new pl.type.Term("' + this.id.replace(/"/g, '\\"') + '", [' + map(this.args, function(arg) { + return arg.compile(); + }) + "])"; + }; + Rule.prototype.compile = function() { + return "new pl.type.Rule(" + this.head.compile() + ", " + (this.body === null ? "null" : this.body.compile()) + ")"; + }; + Session.prototype.compile = function() { + var str, obj = [], rules2; + for (var _indicator in this.modules.user.rules) { + if (!this.modules.user.rules.hasOwnProperty(_indicator)) + continue; + var indicator2 = this.modules.user.rules[_indicator]; + rules2 = []; + str = '"' + _indicator + '": ['; + for (var i2 = 0; i2 < indicator2.length; i2++) { + rules2.push(indicator2[i2].compile()); + } + str += rules2.join(); + str += "]"; + obj.push(str); + } + return "{" + obj.join() + "};"; + }; + Module.prototype.compile = function() { + var length = 0; + var dependencies = 0; + var str = "var pl;\n"; + str += "(function(pl) {\n"; + str += ' var name = "' + this.id + '";\n'; + str += " var predicates = function() {\n"; + str += " return {\n"; + for (var prop in this.rules) { + if (length > 0) + str += ",\n"; + str += ' "' + prop + '": '; + if (typeof this.rules[prop] === "function") { + str += this.rules[prop]; + } else { + str += "[\n"; + for (var i2 = 0; i2 < this.rules[prop].length; i2++) { + str += " " + this.rules[prop][i2].compile(); + if (i2 < this.rules[prop].length - 1) + str += ","; + str += "\n"; + } + str += " ]"; + } + length++; + } + str += "\n };\n"; + str += " };\n"; + str += " var exports = ["; + for (var i2 = 0; i2 < this.exports.length; i2++) { + if (i2 > 0) + str += ", "; + str += '"' + this.exports[i2] + '"'; + } + str += "];\n"; + str += " var options = function() {\n"; + str += " return {\n"; + str += " dependencies: ["; + for (var prop in this.modules) { + if (dependencies > 0) + str += ", "; + str += '"' + prop + '"'; + dependencies++; + } + str += "]\n"; + str += " };\n"; + str += "};\n"; + str += " if(typeof module !== 'undefined') {\n"; + str += " module.exports = function(p) {\n"; + str += " pl = p;\n"; + str += " new pl.type.Module(name, predicates(), exports, options());\n"; + str += " };\n"; + str += " } else {\n"; + str += " new pl.type.Module(name, predicates(), exports, options());\n"; + str += " }\n"; + str += "})(pl);\n"; + return str; + }; + Var.prototype.toJavaScript = function() { + return this.toString(); + }; + Num.prototype.toJavaScript = function() { + return this.value; + }; + Term.prototype.toJavaScript = function(options) { + if (this.args.length === 0 && this.indicator !== "[]/0") { + return this.toString(options); + } else if (pl.type.is_list(this)) { + var all_obj = true; + var arr = []; + var obj = {}; + var pointer = this; + var value; + while (pointer.indicator === "./2") { + value = pointer.args[0].toJavaScript(options); + arr.push(value); + all_obj = all_obj && pl.type.is_term(pointer.args[0]) && pointer.args[0].indicator === "-/2" && pl.type.is_atom(pointer.args[0].args[0]); + if (all_obj) + obj[pointer.args[0].args[0].id] = pointer.args[0].args[1].toJavaScript(options); + pointer = pointer.args[1]; + } + if (pointer.indicator === "[]/0") + return all_obj && arr.length > 0 ? obj : arr; + } + return this.toString(options); + }; + Rule.prototype.singleton_variables = function(include_named) { + include_named = include_named || false; + var variables = this.head.variables(); + var count = {}; + var singleton = []; + if (this.body !== null) + variables = variables.concat(this.body.variables()); + for (var i2 = 0; i2 < variables.length; i2++) { + if (count[variables[i2]] === void 0) + count[variables[i2]] = 0; + count[variables[i2]]++; + } + for (var key in count) { + if (!count.hasOwnProperty(key)) + continue; + if (count[key] === 1) { + var charcode = codePointAt(key, 1); + if (!include_named || key === "_") { + if (key === "_" || key[0] === "_" && (charcode === 95 || charcode >= 65 && charcode <= 90)) + continue; + } + singleton.push(key); + } + } + return singleton; + }; + var nodejs_flag = typeof process !== "undefined" && !process.browser; + var nodejs_arguments = nodejs_flag ? arrayToList(map(process.argv.slice(1), function(arg) { + return new Term(arg); + })) : new Term("[]", []); + var pl = { + __env: nodejs_flag ? global : window, + modules: {}, + version, + parser: { + tokenizer: Tokenizer, + expression: parseExpr + }, + utils: { + str_indicator, + codePointAt, + fromCodePoint, + stringLength + }, + statistics: { + getCountTerms: function() { + return term_ref; + } + }, + fromJavaScript: { + test: { + boolean: function(obj, tobj) { + return obj === true || obj === false; + }, + number: function(obj, tobj) { + return typeof obj === "number"; + }, + string: function(obj, tobj) { + return typeof obj === "string"; + }, + list: function(obj, tobj) { + return obj instanceof Array; + }, + variable: function(obj, tobj) { + return obj === void 0; + }, + object: function(obj, tobj) { + tobj = tobj === void 0 ? false : tobj; + return tobj && !(obj instanceof Array) && typeof obj === "object"; + }, + any: function(_, tobj) { + return true; + } + }, + conversion: { + boolean: function(obj, tobj) { + return new Term(obj ? "true" : "false", []); + }, + number: function(obj, tobj) { + return new Num(obj, obj % 1 !== 0); + }, + string: function(obj, tobj) { + return new Term(obj, []); + }, + list: function(obj, tobj) { + tobj = tobj === void 0 ? false : tobj; + var arr = []; + var elem; + for (var i2 = 0; i2 < obj.length; i2++) { + elem = pl.fromJavaScript.apply(obj[i2], tobj); + if (elem === void 0) + return void 0; + arr.push(elem); + } + return arrayToList(arr); + }, + variable: function(obj, tobj) { + return new Var("_"); + }, + object: function(obj, tobj) { + tobj = tobj === void 0 ? false : tobj; + var list = new Term("[]", []); + var arr = []; + for (var prop in obj) { + if (!obj.hasOwnProperty(prop)) + continue; + arr.push(new Term("-", [ + pl.fromJavaScript.apply(prop, tobj), + pl.fromJavaScript.apply(obj[prop], tobj) + ])); + } + return arrayToList(arr); + }, + any: function(obj, tobj) { + return void 0; + } + }, + apply: function(obj, tobj) { + tobj = tobj === void 0 ? false : tobj; + for (var i2 in pl.fromJavaScript.test) + if (i2 !== "any" && pl.fromJavaScript.test[i2](obj, tobj)) + return pl.fromJavaScript.conversion[i2](obj, tobj); + return pl.fromJavaScript.conversion.any(obj, tobj); + } + }, + type: { + Var, + Num, + Term, + Rule, + State, + Stream, + Module, + Thread, + Session, + Substitution, + File: TauFile, + Directory: TauDirectory, + order: [Var, Num, Term, Stream], + compare: function(x, y) { + var ord_x = indexOf(pl.type.order, x.constructor); + var ord_y = indexOf(pl.type.order, y.constructor); + if (ord_x < ord_y) { + return -1; + } else if (ord_x > ord_y) { + return 1; + } else { + if (x.constructor === Num) { + if (x.is_float && y.is_float) + return 0; + else if (x.is_float) + return -1; + else if (y.is_float) + return 1; + } + return 0; + } + }, + is_substitution: function(obj) { + return obj instanceof Substitution; + }, + is_state: function(obj) { + return obj instanceof State; + }, + is_rule: function(obj) { + return obj instanceof Rule; + }, + is_variable: function(obj) { + return obj instanceof Var; + }, + is_stream: function(obj) { + return obj instanceof Stream; + }, + is_anonymous_var: function(obj) { + return obj instanceof Var && obj.id === "_"; + }, + is_callable: function(obj) { + return obj instanceof Term && (indexOf([",/2", ";/2", "->/2"], obj.indicator) === -1 || pl.type.is_callable(obj.args[0]) && pl.type.is_callable(obj.args[1])) || obj instanceof Var; + }, + is_number: function(obj) { + return obj instanceof Num; + }, + is_integer: function(obj) { + return obj instanceof Num && !obj.is_float; + }, + is_float: function(obj) { + return obj instanceof Num && obj.is_float; + }, + is_term: function(obj) { + return obj instanceof Term; + }, + is_atom: function(obj) { + return obj instanceof Term && obj.args.length === 0; + }, + is_ground: function(obj) { + if (obj instanceof Var) + return false; + if (obj instanceof Term) { + for (var i2 = 0; i2 < obj.args.length; i2++) + if (!pl.type.is_ground(obj.args[i2])) + return false; + } + return true; + }, + is_atomic: function(obj) { + return obj instanceof Term && obj.args.length === 0 || obj instanceof Num; + }, + is_compound: function(obj) { + return obj instanceof Term && obj.args.length > 0; + }, + is_list: function(obj) { + return obj instanceof Term && (obj.indicator === "[]/0" || obj.indicator === "./2"); + }, + is_empty_list: function(obj) { + return obj instanceof Term && obj.indicator === "[]/0"; + }, + is_non_empty_list: function(obj) { + return obj instanceof Term && obj.indicator === "./2"; + }, + is_fully_list: function(obj) { + while (obj instanceof Term && obj.indicator === "./2") { + obj = obj.args[1]; + } + return obj instanceof Var || obj instanceof Term && obj.indicator === "[]/0"; + }, + is_instantiated_list: function(obj) { + while (obj instanceof Term && obj.indicator === "./2") { + obj = obj.args[1]; + } + return obj instanceof Term && obj.indicator === "[]/0"; + }, + is_unitary_list: function(obj) { + return obj instanceof Term && obj.indicator === "./2" && obj.args[1] instanceof Term && obj.args[1].indicator === "[]/0"; + }, + is_character: function(obj) { + return obj instanceof Term && obj.args.length === 0 && (obj.id.length === 1 || obj.id.length > 0 && obj.id.length <= 2 && codePointAt(obj.id, 0) >= 65536); + }, + is_in_character: function(obj) { + return obj instanceof Term && (obj.indicator === "end_of_file/0" || obj.id.length === 1 || obj.id.length > 0 && obj.id.length <= 2 && codePointAt(obj.id, 0) >= 65536); + }, + is_character_code: function(obj) { + return obj instanceof Num && !obj.is_float && obj.value >= 0 && obj.value <= 1114111; + }, + is_in_character_code: function(obj) { + return obj instanceof Num && !obj.is_float && obj.value >= -1 && obj.value <= 1114111; + }, + is_byte: function(obj) { + return obj instanceof Num && !obj.is_float && obj.value >= 0 && obj.value <= 255; + }, + is_in_byte: function(obj) { + return obj instanceof Num && !obj.is_float && obj.value >= -1 && obj.value <= 255; + }, + is_operator: function(obj) { + return obj instanceof Term && pl.arithmetic.evaluation[obj.indicator]; + }, + is_directive: function(obj) { + return obj instanceof Term && (pl.directive[obj.indicator] !== void 0 || pl.directive[obj.id + "/*"] !== void 0); + }, + is_builtin: function(obj) { + return obj instanceof Term && pl.builtin.rules.hasOwnProperty(obj.indicator) && obj.indicator !== "goal_expansion/2"; + }, + is_error: function(obj) { + return obj instanceof Term && obj.indicator === "throw/1"; + }, + is_error_state: function(obj) { + return pl.type.is_state(obj) && obj.error && obj.error === true; + }, + is_predicate_indicator: function(obj) { + return obj instanceof Term && obj.indicator === "//2" && obj.args[0] instanceof Term && obj.args[0].args.length === 0 && obj.args[1] instanceof Num && obj.args[1].is_float === false; + }, + is_flag: function(obj) { + return obj instanceof Term && obj.args.length === 0 && pl.flag[obj.id] !== void 0; + }, + is_value_flag: function(flag, obj) { + if (!pl.type.is_flag(flag)) + return false; + for (var value in pl.flag[flag.id].allowed) { + if (!pl.flag[flag.id].allowed.hasOwnProperty(value)) + continue; + if (pl.flag[flag.id].allowed[value].equals(obj)) + return true; + } + return false; + }, + is_io_mode: function(obj) { + return pl.type.is_atom(obj) && ["read", "write", "append"].indexOf(obj.id) !== -1; + }, + is_stream_option: function(obj) { + return pl.type.is_term(obj) && (obj.indicator === "alias/1" && pl.type.is_atom(obj.args[0]) || obj.indicator === "reposition/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || obj.indicator === "type/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "text" || obj.args[0].id === "binary") || obj.indicator === "eof_action/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "error" || obj.args[0].id === "eof_code" || obj.args[0].id === "reset")); + }, + is_stream_position: function(obj) { + return pl.type.is_term(obj) && (obj.indicator === "end_of_stream/0" || obj.indicator === "past_end_of_stream/0" || obj.indicator === "position/3" && pl.type.is_integer(obj.args[0]) && pl.type.is_integer(obj.args[1]) && pl.type.is_integer(obj.args[2])); + }, + is_stream_property: function(obj) { + return pl.type.is_term(obj) && (obj.indicator === "input/0" || obj.indicator === "output/0" || obj.indicator === "alias/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0])) || obj.indicator === "file_name/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0])) || obj.indicator === "reposition/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false")) || obj.indicator === "type/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "text" || obj.args[0].id === "binary")) || obj.indicator === "mode/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "read" || obj.args[0].id === "write" || obj.args[0].id === "append")) || obj.indicator === "eof_action/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "error" || obj.args[0].id === "eof_code" || obj.args[0].id === "reset")) || obj.indicator === "end_of_stream/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "at" || obj.args[0].id === "past" || obj.args[0].id === "not")) || obj.indicator === "position/1" && (pl.type.is_variable(obj.args[0]) || pl.type.is_term(obj.args[0]) && obj.args[0].indicator === "position/3" && (pl.type.is_variable(obj.args[0].args[0]) || pl.type.is_integer(obj.args[0].args[0])) && (pl.type.is_variable(obj.args[0].args[1]) || pl.type.is_integer(obj.args[0].args[1])) && (pl.type.is_variable(obj.args[0].args[2]) || pl.type.is_integer(obj.args[0].args[2])))); + }, + is_streamable: function(obj) { + return obj.__proto__.stream !== void 0; + }, + is_read_option: function(obj) { + return pl.type.is_term(obj) && ["variables/1", "variable_names/1", "singletons/1"].indexOf(obj.indicator) !== -1; + }, + is_write_option: function(obj) { + return pl.type.is_term(obj) && (obj.indicator === "quoted/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || obj.indicator === "ignore_ops/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || obj.indicator === "numbervars/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false") || obj.indicator === "variable_names/1" && pl.type.is_fully_list(obj.args[0])); + }, + is_close_option: function(obj) { + return pl.type.is_term(obj) && obj.indicator === "force/1" && pl.type.is_atom(obj.args[0]) && (obj.args[0].id === "true" || obj.args[0].id === "false"); + }, + is_modifiable_flag: function(obj) { + return pl.type.is_flag(obj) && pl.flag[obj.id].changeable; + }, + is_module: function(obj) { + return obj instanceof Module; + }, + is_file: function(obj) { + return obj instanceof TauFile; + }, + is_directory: function(obj) { + return obj instanceof TauDirectory; + }, + is_predicate_property: function(obj) { + return pl.type.is_term(obj) && (obj.indicator === "built_in/0" || obj.indicator === "static/0" || obj.indicator === "dynamic/0" || obj.indicator === "native_code/0" || obj.indicator === "multifile/0" || obj.indicator === "meta_predicate/1"); + }, + is_meta_argument_specifier: function(obj) { + return pl.type.is_integer(obj) && obj.value >= 0 || pl.type.is_atom(obj) && indexOf(["+", "-", "?", "*", "^", ":", "//"], obj.id) !== -1; + }, + is_time_property: function(obj) { + return pl.type.is_term(obj) && obj.args.length === 1 && (pl.type.is_variable(obj.args[0]) || pl.type.is_integer(obj.args[0])) && indexOf(["year", "month", "day", "hours", "minutes", "seconds", "milliseconds", "weekday"], obj.id) !== -1; + } + }, + arithmetic: { + evaluation: { + "e/0": { + type_args: null, + type_result: true, + fn: function(_) { + return Math.E; + } + }, + "pi/0": { + type_args: null, + type_result: true, + fn: function(_) { + return Math.PI; + } + }, + "tau/0": { + type_args: null, + type_result: true, + fn: function(_) { + return 2 * Math.PI; + } + }, + "epsilon/0": { + type_args: null, + type_result: true, + fn: function(_) { + return Number.EPSILON; + } + }, + "+/1": { + type_args: null, + type_result: null, + fn: function(x, _) { + return x; + } + }, + "-/1": { + type_args: null, + type_result: null, + fn: function(x, _) { + return -x; + } + }, + "\\/1": { + type_args: false, + type_result: false, + fn: function(x, _) { + return ~x; + } + }, + "abs/1": { + type_args: null, + type_result: null, + fn: function(x, _) { + return Math.abs(x); + } + }, + "sign/1": { + type_args: null, + type_result: null, + fn: function(x, _) { + return Math.sign(x); + } + }, + "float_integer_part/1": { + type_args: true, + type_result: false, + fn: function(x, _) { + return parseInt(x); + } + }, + "float_fractional_part/1": { + type_args: true, + type_result: true, + fn: function(x, _) { + return x - parseInt(x); + } + }, + "float/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return parseFloat(x); + } + }, + "floor/1": { + type_args: true, + type_result: false, + fn: function(x, _) { + return Math.floor(x); + } + }, + "truncate/1": { + type_args: true, + type_result: false, + fn: function(x, _) { + return parseInt(x); + } + }, + "round/1": { + type_args: true, + type_result: false, + fn: function(x, _) { + return Math.round(x); + } + }, + "ceiling/1": { + type_args: true, + type_result: false, + fn: function(x, _) { + return Math.ceil(x); + } + }, + "sin/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.sin(x); + } + }, + "cos/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.cos(x); + } + }, + "tan/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.tan(x); + } + }, + "asin/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return Math.abs(x) <= 1 ? Math.asin(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "acos/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return Math.abs(x) <= 1 ? Math.acos(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "atan/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.atan(x); + } + }, + "atan2/2": { + type_args: null, + type_result: true, + fn: function(x, y, thread) { + return x === 0 && y === 0 ? pl.error.evaluation("undefined", thread.__call_indicator) : Math.atan2(x, y); + } + }, + "acosh/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return x >= 1 ? Math.acosh(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "asinh/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.asinh(x); + } + }, + "atanh/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return Math.abs(x) < 1 ? Math.atanh(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "cosh/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.cosh(x); + } + }, + "sinh/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.sinh(x); + } + }, + "tanh/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.tanh(x); + } + }, + "exp/1": { + type_args: null, + type_result: true, + fn: function(x, _) { + return Math.exp(x); + } + }, + "sqrt/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return x >= 0 ? Math.sqrt(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "log/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return x > 0 ? Math.log(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "log/2": { + type_args: null, + type_result: true, + fn: function(x, y, thread) { + return x > 0 && y > 0 ? Math.log(y) / Math.log(x) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "log10/1": { + type_args: null, + type_result: true, + fn: function(x, thread) { + return x > 0 ? Math.log(x) / Math.log(10) : pl.error.evaluation("undefined", thread.__call_indicator); + } + }, + "+/2": { + type_args: null, + type_result: null, + fn: function(x, y, _) { + return x + y; + } + }, + "-/2": { + type_args: null, + type_result: null, + fn: function(x, y, _) { + return x - y; + } + }, + "*/2": { + type_args: null, + type_result: null, + fn: function(x, y, _) { + return x * y; + } + }, + "//2": { + type_args: null, + type_result: true, + fn: function(x, y, thread) { + return y ? x / y : pl.error.evaluation("zero_divisor", thread.__call_indicator); + } + }, + "///2": { + type_args: false, + type_result: false, + fn: function(x, y, thread) { + return y ? Math.trunc(x / y) : pl.error.evaluation("zero_divisor", thread.__call_indicator); + } + }, + "div/2": { + type_args: false, + type_result: false, + fn: function(x, y, thread) { + return y ? Math.floor(x / y) : pl.error.evaluation("zero_divisor", thread.__call_indicator); + } + }, + "**/2": { + type_args: null, + type_result: true, + fn: function(x, y, thread) { + return x == 0 && y < 0 ? pl.error.evaluation("zero_divisor", thread.__call_indicator) : Math.pow(x, y); + } + }, + "^/2": { + type_args: null, + type_result: null, + fn: function(x, y, thread) { + return x == 0 && y < 0 ? pl.error.evaluation("zero_divisor", thread.__call_indicator) : Math.pow(x, y); + } + }, + "<>/2": { + type_args: false, + type_result: false, + fn: function(x, y, _) { + return x >> y; + } + }, + "/\\/2": { + type_args: false, + type_result: false, + fn: function(x, y, _) { + return x & y; + } + }, + "\\//2": { + type_args: false, + type_result: false, + fn: function(x, y, _) { + return x | y; + } + }, + "xor/2": { + type_args: false, + type_result: false, + fn: function(x, y, _) { + return x ^ y; + } + }, + "rem/2": { + type_args: false, + type_result: false, + fn: function(x, y, thread) { + return y ? x % y : pl.error.evaluation("zero_divisor", thread.__call_indicator); + } + }, + "mod/2": { + type_args: false, + type_result: false, + fn: function(x, y, thread) { + return y ? x - Math.floor(x / y) * y : pl.error.evaluation("zero_divisor", thread.__call_indicator); + } + }, + "max/2": { + type_args: null, + type_result: null, + fn: function(x, y, _) { + return Math.max(x, y); + } + }, + "min/2": { + type_args: null, + type_result: null, + fn: function(x, y, _) { + return Math.min(x, y); + } + }, + "gcd/2": { + type_args: false, + type_result: false, + fn: function(x, y, _) { + return gcd(x, y); + } + } + } + }, + directive: { + "dynamic/1": function(thread, atom, options) { + var indicators = atom.args[0]; + if (!pl.type.is_list(indicators)) + indicators = arrayToList([indicators]); + var pointer = indicators; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + indicator = pointer.args[0]; + if (pl.type.is_variable(indicator)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_compound(indicator) || indicator.indicator !== "//2") { + thread.throw_warning(pl.error.type("predicate_indicator", indicator, atom.indicator)); + } else if (pl.type.is_variable(indicator.args[0]) || pl.type.is_variable(indicator.args[1])) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(indicator.args[0])) { + thread.throw_warning(pl.error.type("atom", indicator.args[0], atom.indicator)); + } else if (!pl.type.is_integer(indicator.args[1])) { + thread.throw_warning(pl.error.type("integer", indicator.args[1], atom.indicator)); + } else { + var key = indicator.args[0].id + "/" + indicator.args[1].value; + var get_module = thread.session.modules[options.context_module]; + get_module.public_predicates[key] = true; + if (!get_module.rules[key]) + get_module.rules[key] = []; + } + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_term(pointer) || pointer.indicator !== "[]/0") { + thread.throw_warning(pl.error.type("predicate_indicator", indicator, atom.indicator)); + } + }, + "dynamic/*": function(thread, atom) { + for (var i2 = 0; i2 < atom.args.length; i2++) { + pl.directive["dynamic/1"](thread, new Term("dynamic", [atom.args[i2]])); + } + }, + "multifile/1": function(thread, atom, options) { + var indicator2 = atom.args[0]; + if (pl.type.is_variable(indicator2)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_compound(indicator2) || indicator2.indicator !== "//2") { + thread.throw_warning(pl.error.type("predicate_indicator", indicator2, atom.indicator)); + } else if (pl.type.is_variable(indicator2.args[0]) || pl.type.is_variable(indicator2.args[1])) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(indicator2.args[0])) { + thread.throw_warning(pl.error.type("atom", indicator2.args[0], atom.indicator)); + } else if (!pl.type.is_integer(indicator2.args[1])) { + thread.throw_warning(pl.error.type("integer", indicator2.args[1], atom.indicator)); + } else { + var predicate_indicator = atom.args[0].args[0].id + "/" + atom.args[0].args[1].value; + var get_module = thread.session.modules[options.context_module]; + get_module.multifile_predicates[predicate_indicator] = true; + if (!get_module.rules.hasOwnProperty(predicate_indicator)) { + get_module.rules[predicate_indicator] = []; + get_module.public_predicates[predicate_indicator] = false; + } + } + }, + "meta_predicate/1": function(thread, atom, options) { + var options = options === void 0 ? {} : options; + var head = atom.args[0]; + if (pl.type.is_variable(head)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(head)) { + thread.throw_warning(pl.error.type("callable", head, atom.indicator)); + } else { + for (var i2 = 0; i2 < head.args.length; i2++) { + var arg = head.args[i2]; + if (!pl.type.is_meta_argument_specifier(arg)) { + thread.throw_warning(pl.error.type("meta_argument_specifier", arg, atom.indicator)); + return; + } + } + thread.session.modules[options.context_module].meta_predicates[head.indicator] = head; + } + }, + "set_prolog_flag/2": function(thread, atom) { + var flag = atom.args[0], value = atom.args[1]; + if (pl.type.is_variable(flag) || pl.type.is_variable(value)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(flag)) { + thread.throw_warning(pl.error.type("atom", flag, atom.indicator)); + } else if (!pl.type.is_flag(flag)) { + thread.throw_warning(pl.error.domain("prolog_flag", flag, atom.indicator)); + } else if (!pl.type.is_modifiable_flag(flag)) { + thread.throw_warning(pl.error.permission("modify", "flag", flag, atom.indicator)); + } else if (!pl.type.is_value_flag(flag, value)) { + thread.throw_warning(pl.error.domain("flag_value", new Term("+", [flag, value]), atom.indicator)); + } else { + thread.session.flag[flag.id] = value; + } + }, + "module/2": function(thread, atom, options) { + var options = options === void 0 ? {} : options; + options.context_module = options.context_module === void 0 ? "user" : options.context_module; + var module_id = atom.args[0], exports2 = atom.args[1]; + if (pl.type.is_variable(module_id) || pl.type.is_variable(exports2)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(module_id)) { + thread.throw_warning(pl.error.type("atom", module_id, atom.indicator)); + } else if (!pl.type.is_list(exports2)) { + thread.throw_warning(pl.error.type("list", exports2, atom.indicator)); + } else { + if (!pl.type.is_module(thread.session.modules[module_id.indicator])) { + var pointer = exports2; + var indicators = []; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var predicate = pointer.args[0]; + if (!pl.type.is_predicate_indicator(predicate)) { + thread.throw_warning(pl.error.type("predicate_indicator", predicate, atom.indicator)); + } else { + indicators.push(predicate.args[0].id + "/" + predicate.args[1].value); + } + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_empty_list(pointer)) { + thread.throw_warning(pl.error.type("list", exports2, atom.indicator)); + } + var new_module = new Module(module_id.id, {}, indicators, { + session: thread.session + }); + thread.session.modules[module_id.id] = new_module; + thread.session.modules[options.context_module].modules[module_id.id] = new_module; + options.context_module = module_id.id; + } else { + thread.throw_warning(pl.error.permission("create", "module", module_id, atom.indicator)); + } + } + }, + "use_module/1": function(thread, atom, options) { + var options = options === void 0 ? {} : options; + options.context_module = options.context_module === void 0 ? "user" : options.context_module; + var module_id = atom.args[0]; + if (pl.type.is_variable(module_id)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_term(module_id)) { + thread.throw_warning(pl.error.type("term", module_id, atom.indicator)); + } else { + if (module_id.indicator === "library/1") { + var name = module_id.args[0].id; + var get_module = pl.modules[name]; + if (pl.type.is_module(get_module)) { + if (!thread.session.modules[options.context_module].modules.hasOwnProperty(name)) { + thread.session.modules[name] = get_module; + thread.session.modules[options.context_module].modules[name] = get_module; + for (var i2 = 0; i2 < get_module.dependencies.length; i2++) { + var term = new Term("use_module", [new Term("library", [new Term(get_module.dependencies[i2])])]); + pl.directive["use_module/1"](thread, term, { + context_module: name + }); + } + } + } else { + thread.throw_warning(pl.error.existence("module", module_id, atom.indicator)); + } + } else { + var name = module_id.id; + thread.consult(name, { + context_module: options.context_module, + text: false, + success: function() { + parseProgram(thread, options.string, options); + }, + error: function() { + options.error(pl.error.existence("module", module_id, atom.indicator)); + } + }); + return true; + } + } + }, + "char_conversion/2": function(thread, atom, options) { + var inchar = atom.args[0], outchar = atom.args[1]; + if (pl.type.is_variable(inchar) || pl.type.is_variable(outchar)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_character(inchar)) { + thread.throw_warning(pl.error.type("character", inchar, atom.indicator)); + } else if (!pl.type.is_character(outchar)) { + thread.throw_warning(pl.error.type("character", outchar, atom.indicator)); + } else { + if (inchar.id === outchar.id) { + delete thread.session.__char_conversion[inchar.id]; + } else { + thread.session.__char_conversion[inchar.id] = outchar.id; + } + options.tokens = options.tokenizer.get_tokens(options.current_token); + options.current_token = 0; + return true; + } + }, + "op/3": function(thread, atom) { + var priority = atom.args[0], type = atom.args[1], operators = atom.args[2]; + if (pl.type.is_atom(operators)) + operators = new Term(".", [operators, new Term("[]")]); + if (pl.type.is_variable(priority) || pl.type.is_variable(type) || pl.type.is_variable(operators)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(priority)) { + thread.throw_warning(pl.error.type("integer", priority, atom.indicator)); + } else if (!pl.type.is_atom(type)) { + thread.throw_warning(pl.error.type("atom", type, atom.indicator)); + } else if (!pl.type.is_list(operators)) { + thread.throw_warning(pl.error.type("list", operators, atom.indicator)); + } else if (pl.type.is_empty_list(operators)) { + thread.throw_warning(pl.error.permission("create", "operator", operators, atom.indicator)); + } else { + var pointer = operators; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var operator = pointer.args[0]; + pointer = pointer.args[1]; + if (pl.type.is_variable(operator)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(operator)) { + thread.throw_warning(pl.error.type("atom", operator, atom.indicator)); + } else if (priority.value < 0 || priority.value > 1200) { + thread.throw_warning(pl.error.domain("operator_priority", priority, atom.indicator)); + } else if (operator.id === ",") { + thread.throw_error(pl.error.permission("modify", "operator", operator, atom.indicator)); + } else if (operator.id === "{}") { + thread.throw_warning(pl.error.permission("create", "operator", operator, atom.indicator)); + } else if (operator.id === "[]") { + thread.throw_warning(pl.error.permission("create", "operator", operator, atom.indicator)); + } else if (operator.id === "|" && priority.value !== 0 && (priority.value < 1001 || type.id.length !== 3)) { + thread.throw_warning(pl.error.permission("create", "operator", operator, atom.indicator)); + } else if (["fy", "fx", "yf", "xf", "xfx", "yfx", "xfy"].indexOf(type.id) === -1) { + thread.throw_warning(pl.error.domain("operator_specifier", type, atom.indicator)); + } else { + var fix = { prefix: null, infix: null, postfix: null }; + for (var p in thread.session.__operators) { + if (!thread.session.__operators.hasOwnProperty(p)) + continue; + var classes = thread.session.__operators[p][operator.id]; + if (classes) { + if (indexOf(classes, "fx") !== -1) { + fix.prefix = { priority: p, type: "fx" }; + } + if (indexOf(classes, "fy") !== -1) { + fix.prefix = { priority: p, type: "fy" }; + } + if (indexOf(classes, "xf") !== -1) { + fix.postfix = { priority: p, type: "xf" }; + } + if (indexOf(classes, "yf") !== -1) { + fix.postfix = { priority: p, type: "yf" }; + } + if (indexOf(classes, "xfx") !== -1) { + fix.infix = { priority: p, type: "xfx" }; + } + if (indexOf(classes, "xfy") !== -1) { + fix.infix = { priority: p, type: "xfy" }; + } + if (indexOf(classes, "yfx") !== -1) { + fix.infix = { priority: p, type: "yfx" }; + } + } + } + var current_class; + switch (type.id) { + case "fy": + case "fx": + current_class = "prefix"; + break; + case "yf": + case "xf": + current_class = "postfix"; + break; + default: + current_class = "infix"; + break; + } + if (fix.infix && current_class === "postfix" || fix.postfix && current_class === "infix") { + thread.throw_warning(pl.error.permission("create", "operator", operator, atom.indicator)); + } else { + if (fix[current_class]) { + remove(thread.session.__operators[fix[current_class].priority][operator.id], fix[current_class].type); + if (thread.session.__operators[fix[current_class].priority][operator.id].length === 0) { + delete thread.session.__operators[fix[current_class].priority][operator.id]; + } + } + if (priority.value > 0) { + if (!thread.session.__operators[priority.value]) + thread.session.__operators[priority.value.toString()] = {}; + if (!thread.session.__operators[priority.value][operator.id]) + thread.session.__operators[priority.value][operator.id] = []; + thread.session.__operators[priority.value][operator.id].push(type.id); + } + } + } + } + if (pl.type.is_variable(pointer)) { + thread.throw_warning(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_term(pointer) || pointer.indicator !== "[]/0") { + thread.throw_warning(pl.error.type("list", operators, atom.indicator)); + return; + } + } + }, + "initialization/1": function(thread, atom, options) { + var goal = atom.args[0]; + options.initialization.push(goal); + } + }, + flag: { + bounded: { + allowed: [new Term("true"), new Term("false")], + value: new Term("true"), + changeable: false + }, + max_integer: { + allowed: [new Num(Number.MAX_SAFE_INTEGER)], + value: new Num(Number.MAX_SAFE_INTEGER), + changeable: false + }, + min_integer: { + allowed: [new Num(Number.MIN_SAFE_INTEGER)], + value: new Num(Number.MIN_SAFE_INTEGER), + changeable: false + }, + integer_rounding_function: { + allowed: [new Term("down"), new Term("toward_zero")], + value: new Term("toward_zero"), + changeable: false + }, + char_conversion: { + allowed: [new Term("on"), new Term("off")], + value: new Term("on"), + changeable: true + }, + debug: { + allowed: [new Term("on"), new Term("off")], + value: new Term("off"), + changeable: true + }, + max_arity: { + allowed: [new Term("unbounded")], + value: new Term("unbounded"), + changeable: false + }, + unknown: { + allowed: [new Term("error"), new Term("fail"), new Term("warning")], + value: new Term("error"), + changeable: true + }, + double_quotes: { + allowed: [new Term("chars"), new Term("codes"), new Term("atom")], + value: new Term("chars"), + changeable: true + }, + occurs_check: { + allowed: [new Term("false"), new Term("true")], + value: new Term("false"), + changeable: true + }, + dialect: { + allowed: [new Term("tau")], + value: new Term("tau"), + changeable: false + }, + version_data: { + allowed: [new Term("tau", [new Num(version.major, false), new Num(version.minor, false), new Num(version.patch, false), new Term(version.status)])], + value: new Term("tau", [new Num(version.major, false), new Num(version.minor, false), new Num(version.patch, false), new Term(version.status)]), + changeable: false + }, + nodejs: { + allowed: [new Term("true"), new Term("false")], + value: new Term(nodejs_flag ? "true" : "false"), + changeable: false + }, + argv: { + allowed: [nodejs_arguments], + value: nodejs_arguments, + changeble: false + } + }, + unify: function(t1, t2, occurs_check) { + occurs_check = occurs_check === void 0 ? false : occurs_check; + var left = Array.isArray(t1) ? t1 : [t1]; + var right = Array.isArray(t2) ? t2 : [t2]; + if (left.length !== right.length) + return null; + var subs = new Substitution(); + while (left.length > 0) { + var s = left.pop(); + var t = right.pop(); + if (pl.type.is_variable(s)) + s = s.apply(subs); + if (pl.type.is_variable(t)) + t = t.apply(subs); + if (s == t) + continue; + if (pl.type.is_term(s) && pl.type.is_term(t)) { + if (s.indicator !== t.indicator) + return null; + for (var i2 = s.args.length - 1; i2 >= 0; i2--) { + left.push(s.args[i2]); + right.push(t.args[i2]); + } + } else if (pl.type.is_number(s) && pl.type.is_number(t)) { + if (s.value !== t.value || s.is_float !== t.is_float) + return null; + } else if (pl.type.is_variable(s)) { + t = t.apply(subs); + if (pl.type.is_variable(t) && s.id === t.id) + continue; + if (occurs_check === true && indexOf(t.variables(), s.id) !== -1) + return null; + if (s.id !== "_") + subs.add(s.id, t); + } else if (pl.type.is_variable(t)) { + left.push(t); + right.push(s); + } else if (s.unify !== void 0) { + var user_subs = s.apply(subs).unify(t.apply(subs), occurs_check); + if (user_subs == null) + return null; + for (var i2 in user_subs.links) + subs.add(i2, user_subs.links[i2]); + } else { + return null; + } + } + return subs.apply(subs); + }, + is_rename: function(obj1, obj2, links) { + links = links || {}; + if (obj1.is_rename && obj2.is_rename) + return obj1.is_rename(obj2, links); + else if (obj1.equals && obj2.equals) + return obj1.equals(obj2); + else + return false; + }, + compare: function(obj1, obj2) { + var type = pl.type.compare(obj1, obj2); + return type !== 0 ? type : obj1.compare(obj2); + }, + arithmetic_compare: function(thread, obj1, obj2) { + var expr1 = obj1.interpret(thread); + if (!pl.type.is_number(expr1)) { + return expr1; + } else { + var expr2 = obj2.interpret(thread); + if (!pl.type.is_number(expr2)) { + return expr2; + } else { + return expr1.value < expr2.value ? -1 : expr1.value > expr2.value ? 1 : 0; + } + } + }, + operate: function(thread, obj) { + if (pl.type.is_operator(obj)) { + var op = pl.type.is_operator(obj); + var args = [], value; + var type = false; + for (var i2 = 0; i2 < obj.args.length; i2++) { + value = obj.args[i2].interpret(thread); + if (!pl.type.is_number(value)) { + return value; + } else if (op.type_args !== null && value.is_float !== op.type_args) { + return pl.error.type(op.type_args ? "float" : "integer", value, thread.__call_indicator); + } else { + args.push(value.value); + } + type = type || value.is_float; + } + args.push(thread); + value = pl.arithmetic.evaluation[obj.indicator].fn.apply(this, args); + if (obj.indicator === "^/2" && !type && value !== parseInt(value, 10)) + return pl.error.type("float", new Num(args[0], false), thread.__call_indicator); + type = op.type_result === null ? type : op.type_result; + if (pl.type.is_term(value)) { + return value; + } else if (value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) { + return pl.error.evaluation("float_overflow", thread.__call_indicator); + } else if (type === false && thread.get_flag("bounded").id === "true" && (value > thread.get_flag("max_integer").value || value < thread.get_flag("min_integer").value)) { + return pl.error.evaluation("int_overflow", thread.__call_indicator); + } else { + return new Num(value, type); + } + } else { + return pl.error.type("evaluable", str_indicator(obj.indicator), thread.__call_indicator); + } + }, + error: { + existence: function(type, object, indicator2) { + if (typeof object === "string") + object = str_indicator(object); + return new Term("error", [new Term("existence_error", [new Term(type), object]), str_indicator(indicator2)]); + }, + type: function(expected, found, indicator2) { + return new Term("error", [new Term("type_error", [new Term(expected), found]), str_indicator(indicator2)]); + }, + instantiation: function(indicator2) { + return new Term("error", [new Term("instantiation_error"), str_indicator(indicator2)]); + }, + uninstantiation: function(found, indicator2) { + return new Term("error", [new Term("uninstantiation_error", [new Term(found)]), str_indicator(indicator2)]); + }, + domain: function(expected, found, indicator2) { + return new Term("error", [new Term("domain_error", [new Term(expected), found]), str_indicator(indicator2)]); + }, + representation: function(flag, indicator2) { + return new Term("error", [new Term("representation_error", [new Term(flag)]), str_indicator(indicator2)]); + }, + permission: function(operation, type, found, indicator2) { + return new Term("error", [new Term("permission_error", [new Term(operation), new Term(type), found]), str_indicator(indicator2)]); + }, + evaluation: function(error, indicator2) { + return new Term("error", [new Term("evaluation_error", [new Term(error)]), str_indicator(indicator2)]); + }, + syntax: function(token, expected, last) { + token = token || { value: "", line: 0, column: 0, matches: [""], start: 0 }; + var position = last && token.matches.length > 0 ? token.start + token.matches[0].length : token.start; + var found = last ? new Term("token_not_found") : new Term("found", [new Term(token.value.toString())]); + var info = new Term(".", [new Term("line", [new Num(token.line + 1)]), new Term(".", [new Term("column", [new Num(position)]), new Term(".", [found, new Term("[]", [])])])]); + return new Term("error", [new Term("syntax_error", [new Term(expected)]), info]); + }, + syntax_by_predicate: function(expected, indicator2) { + return new Term("error", [new Term("syntax_error", [new Term(expected)]), str_indicator(indicator2)]); + } + }, + warning: { + singleton: function(variables, rule, line) { + var list = new Term("[]"); + for (var i2 = variables.length - 1; i2 >= 0; i2--) + list = new Term(".", [new Var(variables[i2]), list]); + return new Term("warning", [new Term("singleton_variables", [list, str_indicator(rule)]), new Term(".", [new Term("line", [new Num(line, false)]), new Term("[]")])]); + }, + failed_goal: function(goal, line) { + return new Term("warning", [new Term("failed_goal", [goal]), new Term(".", [new Term("line", [new Num(line, false)]), new Term("[]")])]); + } + }, + format_variable: function(id, variable) { + var charcode = variable && variable.length > 0 ? codePointAt(variable, 1) : 0; + if (variable === "_" || variable && variable[0] === "_" && (charcode === 95 || charcode >= 65 && charcode <= 90)) + return "__" + id; + return "_" + id; + }, + format_answer: function(answer, thread, options) { + if (thread instanceof Session) + thread = thread.thread; + var options = options ? options : {}; + options.session = thread ? thread.session : void 0; + if (pl.type.is_error(answer)) { + return "uncaught exception: " + answer.args[0].toString(options); + } else if (answer === false) { + return "false"; + } else if (answer === null) { + return "limit exceeded"; + } else { + var i2 = 0; + var str = ""; + if (pl.type.is_substitution(answer)) { + var dom = answer.domain(true); + for (var link in answer.links) { + if (!answer.links.hasOwnProperty(link)) + continue; + if (pl.type.is_variable(answer.links[link])) { + var links = {}; + links[answer.links[link].id] = new Var(link); + answer = answer.apply(new Substitution(links)); + } + } + answer = answer.filter(function(id, value) { + return !pl.type.is_variable(value) || pl.type.is_variable(value) && answer.has_attributes(id) || indexOf(dom, value.id) !== -1 && id !== value.id; + }); + } + for (var link in answer.links) { + if (!answer.links.hasOwnProperty(link)) + continue; + if (pl.type.is_variable(answer.links[link]) && link === answer.links[link].id) { + var attrs = answer.attrs[link]; + for (var module3 in attrs) { + if (!attrs.hasOwnProperty(module3)) + continue; + i2++; + if (str !== "") + str += ", "; + str += "put_attr(" + link + ", " + module3 + ", " + attrs[module3].toString(options) + ")"; + } + } else { + i2++; + if (str !== "") + str += ", "; + str += link.toString(options) + " = " + answer.links[link].toString(options, { priority: "700", class: "xfx", indicator: "=/2" }, "right"); + } + } + if (i2 === 0) { + return "true"; + } else { + return str; + } + } + }, + flatten_error: function(error) { + if (!pl.type.is_error(error)) + return null; + error = error.args[0]; + var obj = {}; + obj.type = error.args[0].id; + obj.thrown = obj.type === "syntax_error" ? null : error.args[1].id; + obj.expected = null; + obj.found = null; + obj.representation = null; + obj.existence = null; + obj.existence_type = null; + obj.line = null; + obj.column = null; + obj.permission_operation = null; + obj.permission_type = null; + obj.evaluation_type = null; + if (obj.type === "type_error" || obj.type === "domain_error") { + obj.expected = error.args[0].args[0].id; + obj.found = error.args[0].args[1].toString(); + } else if (obj.type === "syntax_error") { + if (error.args[1].indicator === "./2") { + obj.expected = error.args[0].args[0].id; + obj.found = error.args[1].args[1].args[1].args[0]; + obj.found = obj.found.id === "token_not_found" ? obj.found.id : obj.found.args[0].id; + obj.line = error.args[1].args[0].args[0].value; + obj.column = error.args[1].args[1].args[0].args[0].value; + } else { + obj.thrown = error.args[1].id; + } + } else if (obj.type === "permission_error") { + obj.found = error.args[0].args[2].toString(); + obj.permission_operation = error.args[0].args[0].id; + obj.permission_type = error.args[0].args[1].id; + } else if (obj.type === "evaluation_error") { + obj.evaluation_type = error.args[0].args[0].id; + } else if (obj.type === "representation_error") { + obj.representation = error.args[0].args[0].id; + } else if (obj.type === "existence_error") { + obj.existence = error.args[0].args[1].toString(); + obj.existence_type = error.args[0].args[0].id; + } + return obj; + }, + create: function(limit) { + return new pl.type.Session(limit); + } + }; + pl.builtin = new Module("system", { + "goal_expansion/2": [ + new Rule(new Term("goal_expansion", [new Term(",", [new Var("X"), new Var("Y")]), new Term(",", [new Var("X_"), new Var("Y_")])]), new Term(";", [new Term(",", [new Term("goal_expansion", [new Var("X"), new Var("X_")]), new Term(";", [new Term("goal_expansion", [new Var("Y"), new Var("Y_")]), new Term("=", [new Var("Y_"), new Var("Y")])])]), new Term(",", [new Term("=", [new Var("X"), new Var("X_")]), new Term("goal_expansion", [new Var("Y"), new Var("Y_")])])])), + new Rule(new Term("goal_expansion", [new Term(";", [new Var("X"), new Var("Y")]), new Term(";", [new Var("X_"), new Var("Y_")])]), new Term(";", [new Term(",", [new Term("goal_expansion", [new Var("X"), new Var("X_")]), new Term(";", [new Term("goal_expansion", [new Var("Y"), new Var("Y_")]), new Term("=", [new Var("Y_"), new Var("Y")])])]), new Term(",", [new Term("=", [new Var("X"), new Var("X_")]), new Term("goal_expansion", [new Var("Y"), new Var("Y_")])])])), + new Rule(new Term("goal_expansion", [new Term("->", [new Var("X"), new Var("Y")]), new Term("->", [new Var("X_"), new Var("Y_")])]), new Term(";", [new Term(",", [new Term("goal_expansion", [new Var("X"), new Var("X_")]), new Term(";", [new Term("goal_expansion", [new Var("Y"), new Var("Y_")]), new Term("=", [new Var("Y_"), new Var("Y")])])]), new Term(",", [new Term("=", [new Var("X"), new Var("X_")]), new Term("goal_expansion", [new Var("Y"), new Var("Y_")])])])), + new Rule(new Term("goal_expansion", [new Term("catch", [new Var("X"), new Var("Y"), new Var("Z")]), new Term("catch", [new Var("X_"), new Var("Y"), new Var("Z_")])]), new Term(";", [new Term(",", [new Term("goal_expansion", [new Var("X"), new Var("X_")]), new Term(";", [new Term("goal_expansion", [new Var("Z"), new Var("Z_")]), new Term("=", [new Var("Z_"), new Var("Z")])])]), new Term(",", [new Term("=", [new Var("X_"), new Var("X")]), new Term("goal_expansion", [new Var("Z"), new Var("Z_")])])])), + new Rule(new Term("goal_expansion", [new Term("\\+", [new Var("X")]), new Term("\\+", [new Var("X_")])]), new Term(",", [new Term("nonvar", [new Var("X")]), new Term("goal_expansion", [new Var("X"), new Var("X_")])])), + new Rule(new Term("goal_expansion", [new Term("once", [new Var("X")]), new Term("once", [new Var("X_")])]), new Term(",", [new Term("nonvar", [new Var("X")]), new Term("goal_expansion", [new Var("X"), new Var("X_")])])), + new Rule(new Term("goal_expansion", [new Term("findall", [new Var("X"), new Var("Y"), new Var("Z")]), new Term("findall", [new Var("X"), new Var("Y_"), new Var("Z")])]), new Term("goal_expansion", [new Var("Y"), new Var("Y_")])), + new Rule(new Term("goal_expansion", [new Term("setof", [new Var("X"), new Var("Y"), new Var("Z")]), new Term("findall", [new Var("X"), new Var("Y_"), new Var("Z")])]), new Term("goal_expansion", [new Var("Y"), new Var("Y_")])), + new Rule(new Term("goal_expansion", [new Term("bagof", [new Var("X"), new Var("Y"), new Var("Z")]), new Term("findall", [new Var("X"), new Var("Y_"), new Var("Z")])]), new Term("goal_expansion", [new Var("Y"), new Var("Y_")])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X")]), new Term("call", [new Var("X_")])]), new Term(",", [new Term("nonvar", [new Var("X")]), new Term("goal_expansion", [new Var("X"), new Var("X_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term("[]", [])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1"), new Var("A2")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term(".", [new Var("A2"), new Term("[]", [])])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1"), new Var("A2"), new Var("A3")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term(".", [new Var("A2"), new Term(".", [new Var("A3"), new Term("[]", [])])])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1"), new Var("A2"), new Var("A3"), new Var("A4")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term(".", [new Var("A2"), new Term(".", [new Var("A3"), new Term(".", [new Var("A4"), new Term("[]", [])])])])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1"), new Var("A2"), new Var("A3"), new Var("A4"), new Var("A5")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term(".", [new Var("A2"), new Term(".", [new Var("A3"), new Term(".", [new Var("A4"), new Term(".", [new Var("A5"), new Term("[]", [])])])])])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1"), new Var("A2"), new Var("A3"), new Var("A4"), new Var("A5"), new Var("A6")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term(".", [new Var("A2"), new Term(".", [new Var("A3"), new Term(".", [new Var("A4"), new Term(".", [new Var("A5"), new Term(".", [new Var("A6"), new Term("[]", [])])])])])])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])), + new Rule(new Term("goal_expansion", [new Term("call", [new Var("X"), new Var("A1"), new Var("A2"), new Var("A3"), new Var("A4"), new Var("A5"), new Var("A6"), new Var("A7")]), new Term("call", [new Var("F_")])]), new Term(",", [new Term("=..", [new Var("F"), new Term(".", [new Var("X"), new Term(".", [new Var("A1"), new Term(".", [new Var("A2"), new Term(".", [new Var("A3"), new Term(".", [new Var("A4"), new Term(".", [new Var("A5"), new Term(".", [new Var("A6"), new Term(".", [new Var("A7"), new Term("[]", [])])])])])])])])])]), new Term("goal_expansion", [new Var("F"), new Var("F_")])])) + ], + "$push_global_stack/2": function(thread, point, atom) { + var stack = atom.args[0], value = atom.args[1]; + if (!pl.type.is_variable(stack)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else { + thread.push_global_stack(stack.id, value); + thread.success(point); + } + }, + "$flush_global_stack/3": function(thread, point, atom) { + var stack = atom.args[0], list = atom.args[1], tail = atom.args[2]; + if (!pl.type.is_variable(stack)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else { + var values = thread.flush_global_stack(stack.id, tail); + thread.prepend([new State( + point.goal.replace(new Term("=", [list, values])), + point.substitution, + point + )]); + } + }, + "$free_variable_set/3": function(thread, point, atom) { + var goal_in = atom.args[0], goal_out = atom.args[1], vars = atom.args[2]; + var bv = []; + var pointer = goal_in; + while (pl.type.is_term(pointer) && pointer.indicator === "^/2") { + bv = bv.concat(pointer.args[0].variables()); + pointer = pointer.args[1]; + } + var gv = pointer.variables(); + var fv = arrayToList(map(difference(gv, bv), function(v) { + return new Var(v); + })); + thread.prepend([ + new State( + point.goal.replace(new Term(",", [ + new Term("=", [goal_out, pointer]), + new Term("=", [vars, fv]) + ])), + point.substitution, + point + ) + ]); + }, + "$member/2": [ + new pl.type.Rule(new pl.type.Term("$member", [new pl.type.Var("X"), new pl.type.Term(".", [new pl.type.Var("X"), new pl.type.Var("_")])]), null), + new pl.type.Rule(new pl.type.Term("$member", [new pl.type.Var("X"), new pl.type.Term(".", [new pl.type.Var("_"), new pl.type.Var("Xs")])]), new pl.type.Term("$member", [new pl.type.Var("X"), new pl.type.Var("Xs")])) + ], + "$bind_bagof_keys/2": [ + new pl.type.Rule(new pl.type.Term("$bind_bagof_keys", [new pl.type.Term("[]", []), new pl.type.Var("_")]), null), + new pl.type.Rule(new pl.type.Term("$bind_bagof_keys", [new pl.type.Term(".", [new pl.type.Term("-", [new pl.type.Var("Key"), new pl.type.Var("_")]), new pl.type.Var("Bag")]), new pl.type.Var("Vars")]), new pl.type.Term(",", [new pl.type.Term("term_variables", [new pl.type.Var("Key"), new pl.type.Var("Vars"), new pl.type.Var("_")]), new pl.type.Term("$bind_bagof_keys", [new pl.type.Var("Bag"), new pl.type.Var("Vars")])])) + ], + "$findall/4": [ + new pl.type.Rule(new pl.type.Term("$findall", [new pl.type.Var("Template0"), new pl.type.Var("Goal0"), new pl.type.Var("Instances"), new pl.type.Var("Tail")]), new pl.type.Term(";", [new pl.type.Term(",", [new pl.type.Term("copy_term", [new pl.type.Term("-", [new pl.type.Var("Template0"), new pl.type.Var("Goal0")]), new pl.type.Term("-", [new pl.type.Var("Template1"), new pl.type.Var("Goal1")])]), new pl.type.Term(",", [new pl.type.Term("call", [new pl.type.Var("Goal1")]), new pl.type.Term(",", [new pl.type.Term("copy_term", [new pl.type.Var("Template1"), new pl.type.Var("Template2")]), new pl.type.Term(",", [new pl.type.Term("$push_global_stack", [new pl.type.Var("Var"), new pl.type.Var("Template2")]), new pl.type.Term("false", [])])])])]), new pl.type.Term("$flush_global_stack", [new pl.type.Var("Var"), new pl.type.Var("Instances"), new pl.type.Var("Tail")])])) + ], + "$bagof/3": [ + new pl.type.Rule(new pl.type.Term("$bagof", [new pl.type.Var("Template"), new pl.type.Var("Goal0"), new pl.type.Var("Answer")]), new pl.type.Term(",", [new pl.type.Term("$free_variable_set", [new pl.type.Term("^", [new pl.type.Var("Template"), new pl.type.Var("Goal0")]), new pl.type.Var("Goal1"), new pl.type.Var("FV")]), new pl.type.Term(",", [new pl.type.Term("findall", [new pl.type.Term("-", [new pl.type.Var("FV"), new pl.type.Var("Template")]), new pl.type.Var("Goal1"), new pl.type.Var("Answers"), new pl.type.Term("[]", [])]), new pl.type.Term(",", [new pl.type.Term("$bind_bagof_keys", [new pl.type.Var("Answers"), new pl.type.Var("_")]), new pl.type.Term(",", [new pl.type.Term("keygroup", [new pl.type.Var("Answers"), new pl.type.Var("KeyGroups")]), new pl.type.Term(",", [new pl.type.Term("keysort", [new pl.type.Var("KeyGroups"), new pl.type.Var("KeySorted")]), new pl.type.Term("$member", [new pl.type.Term("-", [new pl.type.Var("FV"), new pl.type.Var("Answer")]), new pl.type.Var("KeySorted")])])])])])])) + ], + "$setof/3": [ + new pl.type.Rule(new pl.type.Term("$setof", [new pl.type.Var("Template"), new pl.type.Var("Goal0"), new pl.type.Var("Answer")]), new pl.type.Term(",", [new pl.type.Term("$free_variable_set", [new pl.type.Term("^", [new pl.type.Var("Template"), new pl.type.Var("Goal0")]), new pl.type.Var("Goal1"), new pl.type.Var("FV")]), new pl.type.Term(",", [new pl.type.Term("findall", [new pl.type.Term("-", [new pl.type.Var("FV"), new pl.type.Var("Template")]), new pl.type.Var("Goal1"), new pl.type.Var("Answers"), new pl.type.Term("[]", [])]), new pl.type.Term(",", [new pl.type.Term("$bind_bagof_keys", [new pl.type.Var("Answers"), new pl.type.Var("_")]), new pl.type.Term(",", [new pl.type.Term("keygroup", [new pl.type.Var("Answers"), new pl.type.Var("KeyGroups")]), new pl.type.Term(",", [new pl.type.Term("keysort", [new pl.type.Var("KeyGroups"), new pl.type.Var("KeySorted")]), new pl.type.Term(",", [new pl.type.Term("$member", [new pl.type.Term("-", [new pl.type.Var("FV"), new pl.type.Var("Unsorted")]), new pl.type.Var("KeySorted")]), new pl.type.Term("sort", [new pl.type.Var("Unsorted"), new pl.type.Var("Answer")])])])])])])])) + ], + "$if/3": [ + new pl.type.Rule(new pl.type.Term("$if", [new pl.type.Var("If"), new pl.type.Var("Then"), new pl.type.Var("Else")]), new pl.type.Term(";", [new pl.type.Term(",", [new pl.type.Term("call", [new pl.type.Var("If")]), new pl.type.Term(",", [new pl.type.Term("$push_global_stack", [new pl.type.Var("Stack"), new pl.type.Var("_")]), new pl.type.Term("call", [new pl.type.Var("Then")])])]), new pl.type.Term(",", [new pl.type.Term("$flush_global_stack", [new pl.type.Var("Stack"), new pl.type.Term("[]", []), new pl.type.Term("[]", [])]), new pl.type.Term("call", [new pl.type.Var("Else")])])])) + ], + "put_attr/3": function(thread, point, atom) { + var variable = atom.args[0], module3 = atom.args[1], value = atom.args[2]; + if (!pl.type.is_variable(variable)) { + thread.throw_error(pl.error.type("variable", variable, atom.indicator)); + } else if (!pl.type.is_atom(module3)) { + thread.throw_error(pl.error.type("atom", module3, atom.indicator)); + } else { + var subs = point.substitution.set_attribute(variable.id, module3, value); + thread.prepend([new State(point.goal.replace(null), subs, point)]); + } + }, + "get_attr/3": function(thread, point, atom) { + var variable = atom.args[0], module3 = atom.args[1], value = atom.args[2]; + if (!pl.type.is_variable(variable)) { + thread.throw_error(pl.error.type("variable", variable, atom.indicator)); + } else if (!pl.type.is_atom(module3)) { + thread.throw_error(pl.error.type("atom", module3, atom.indicator)); + } else { + var attr = point.substitution.get_attribute(variable.id, module3); + if (attr) { + thread.prepend([new State( + point.goal.replace(new Term("=", [value, attr])), + point.substitution, + point + )]); + } + } + }, + "op/3": function(thread, point, atom) { + var priority = atom.args[0], type = atom.args[1], operators = atom.args[2]; + if (pl.type.is_atom(operators)) + operators = new Term(".", [operators, new Term("[]")]); + if (pl.type.is_variable(priority) || pl.type.is_variable(type) || pl.type.is_variable(operators)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(priority)) { + thread.throw_error(pl.error.type("integer", priority, atom.indicator)); + } else if (!pl.type.is_atom(type)) { + thread.throw_error(pl.error.type("atom", type, atom.indicator)); + } else if (!pl.type.is_list(operators)) { + thread.throw_error(pl.error.type("list", operators, atom.indicator)); + } else if (pl.type.is_empty_list(operators)) { + thread.throw_error(pl.error.permission("create", "operator", operators, atom.indicator)); + } else { + var pointer = operators; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var operator = pointer.args[0]; + pointer = pointer.args[1]; + if (pl.type.is_variable(operator)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_atom(operator)) { + thread.throw_error(pl.error.type("atom", operator, atom.indicator)); + return; + } else if (priority.value < 0 || priority.value > 1200) { + thread.throw_error(pl.error.domain("operator_priority", priority, atom.indicator)); + return; + } else if (operator.id === ",") { + thread.throw_error(pl.error.permission("modify", "operator", operator, atom.indicator)); + return; + } else if (operator.id === "{}") { + thread.throw_error(pl.error.permission("create", "operator", operator, atom.indicator)); + return; + } else if (operator.id === "[]") { + thread.throw_error(pl.error.permission("create", "operator", operator, atom.indicator)); + return; + } else if (operator.id === "|" && priority.value !== 0 && (priority.value < 1001 || type.id.length !== 3)) { + thread.throw_error(pl.error.permission("create", "operator", operator, atom.indicator)); + return; + } else if (["fy", "fx", "yf", "xf", "xfx", "yfx", "xfy"].indexOf(type.id) === -1) { + thread.throw_error(pl.error.domain("operator_specifier", type, atom.indicator)); + return; + } else { + var fix = { prefix: null, infix: null, postfix: null }; + for (var p in thread.session.__operators) { + if (!thread.session.__operators.hasOwnProperty(p)) + continue; + var classes = thread.session.__operators[p][operator.id]; + if (classes) { + if (indexOf(classes, "fx") !== -1) { + fix.prefix = { priority: p, type: "fx" }; + } + if (indexOf(classes, "fy") !== -1) { + fix.prefix = { priority: p, type: "fy" }; + } + if (indexOf(classes, "xf") !== -1) { + fix.postfix = { priority: p, type: "xf" }; + } + if (indexOf(classes, "yf") !== -1) { + fix.postfix = { priority: p, type: "yf" }; + } + if (indexOf(classes, "xfx") !== -1) { + fix.infix = { priority: p, type: "xfx" }; + } + if (indexOf(classes, "xfy") !== -1) { + fix.infix = { priority: p, type: "xfy" }; + } + if (indexOf(classes, "yfx") !== -1) { + fix.infix = { priority: p, type: "yfx" }; + } + } + } + var current_class; + switch (type.id) { + case "fy": + case "fx": + current_class = "prefix"; + break; + case "yf": + case "xf": + current_class = "postfix"; + break; + default: + current_class = "infix"; + break; + } + if (fix.infix && current_class === "postfix" || fix.postfix && current_class === "infix") { + thread.throw_error(pl.error.permission("create", "operator", operator, atom.indicator)); + return; + } else { + if (fix[current_class]) { + remove(thread.session.__operators[fix[current_class].priority][operator.id], fix[current_class].type); + if (thread.session.__operators[fix[current_class].priority][operator.id].length === 0) { + delete thread.session.__operators[fix[current_class].priority][operator.id]; + } + } + if (priority.value > 0) { + if (!thread.session.__operators[priority.value]) + thread.session.__operators[priority.value.toString()] = {}; + if (!thread.session.__operators[priority.value][operator.id]) + thread.session.__operators[priority.value][operator.id] = []; + thread.session.__operators[priority.value][operator.id].push(type.id); + } + } + } + } + if (pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_term(pointer) || pointer.indicator !== "[]/0") { + thread.throw_error(pl.error.type("list", operators, atom.indicator)); + return; + } else { + thread.success(point); + } + } + }, + "current_op/3": function(thread, point, atom) { + var priority = atom.args[0], specifier = atom.args[1], operator = atom.args[2]; + var points = []; + if (!pl.type.is_variable(priority) && !pl.type.is_integer(priority)) { + thread.throw_error(pl.error.type("integer", priority, atom.indicator)); + } else if (pl.type.is_integer(priority) && (priority.value < 0 || priority.value > 1200)) { + thread.throw_error(pl.error.domain("operator_priority", priority, atom.indicator)); + } else if (!pl.type.is_variable(specifier) && !pl.type.is_atom(specifier)) { + thread.throw_error(pl.error.type("atom", specifier, atom.indicator)); + } else if (pl.type.is_atom(specifier) && indexOf(["fy", "fx", "yf", "xf", "xfx", "yfx", "xfy"], specifier.id) === -1) { + thread.throw_error(pl.error.domain("operator_specifier", specifier, atom.indicator)); + } else if (!pl.type.is_variable(operator) && !pl.type.is_atom(operator)) { + thread.throw_error(pl.error.type("atom", operator, atom.indicator)); + } else { + for (var p in thread.session.__operators) + for (var o in thread.session.__operators[p]) + for (var i2 = 0; i2 < thread.session.__operators[p][o].length; i2++) + points.push(new State( + point.goal.replace( + new Term(",", [ + new Term("=", [new Num(p, false), priority]), + new Term(",", [ + new Term("=", [new Term(thread.session.__operators[p][o][i2], []), specifier]), + new Term("=", [new Term(o, []), operator]) + ]) + ]) + ), + point.substitution, + point + )); + thread.prepend(points); + } + }, + ";/2": function(thread, point, atom) { + var left = atom.args[0], right = atom.args[1]; + var context_left = left.args[0]; + var free_left = left.indicator === ":/2" ? left.args[1] : left; + if (pl.type.is_term(free_left) && free_left.indicator === "->/2") { + var cond = left.indicator === ":/2" ? new Term(":", [context_left, new Term("call", [free_left.args[0]])]) : free_left.args[0]; + var then = left.indicator === ":/2" ? new Term(":", [context_left, free_left.args[1]]) : free_left.args[1]; + var otherwise = right; + var goal_fst = point.goal.replace(new Term(",", [cond, new Term(",", [new Term("!"), then])])); + var goal_snd = point.goal.replace(new Term(",", [new Term("!"), otherwise])); + thread.prepend([ + new State(goal_fst, point.substitution, point), + new State(goal_snd, point.substitution, point) + ]); + } else if (pl.type.is_term(free_left) && free_left.indicator === "*->/2") { + var cond = left.indicator === ":/2" ? new Term(":", [context_left, free_left.args[0]]) : free_left.args[0]; + var then = left.indicator === ":/2" ? new Term(":", [context_left, free_left.args[1]]) : free_left.args[1]; + var otherwise = right; + thread.prepend([new State( + point.goal.replace(new Term("$if", [cond, then, otherwise])), + point.substitution, + point + )]); + } else { + thread.prepend([ + new State(point.goal.replace(left), point.substitution, point), + new State(point.goal.replace(right), point.substitution, point) + ]); + } + }, + "!/0": function(thread, point, atom) { + var parent_cut, last_cut, states = []; + parent_cut = point; + last_cut = null; + while (parent_cut.parent !== null && parent_cut.parent.goal.search(atom)) { + last_cut = parent_cut; + parent_cut = parent_cut.parent; + if (parent_cut.goal !== null) { + var selected = parent_cut.goal.select(); + if (selected && selected.indicator === ":/2") + selected = selected.args[1]; + if (selected && selected.id === "call" && selected.search(atom)) { + parent_cut = last_cut; + break; + } + } + } + var setup_call_cleanup = null; + for (var i2 = thread.points.length - 1; i2 >= 0; i2--) { + var state = thread.points[i2]; + var node = state.parent; + while (node !== null && node !== parent_cut.parent) { + node = node.parent; + } + if (node === null && node !== parent_cut.parent) + states.push(state); + else if (state.setup_call_cleanup_goal) + setup_call_cleanup = state.setup_call_cleanup_goal; + } + thread.points = states.reverse(); + thread.prepend([new State( + point.goal.replace(setup_call_cleanup), + point.substitution, + point + )]); + }, + "\\+/1": function(thread, point, atom) { + var goal = atom.args[0]; + if (pl.type.is_variable(goal)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(goal)) { + thread.throw_error(pl.error.type("callable", goal, atom.indicator)); + } else { + thread.prepend([ + new State(point.goal.replace(new Term(",", [new Term(",", [new Term("call", [goal]), new Term("!", [])]), new Term("fail", [])])), point.substitution, point), + new State(point.goal.replace(null), point.substitution, point) + ]); + } + }, + "->/2": function(thread, point, atom) { + var cond = atom.args[0], then = atom.args[1]; + var goal = point.goal.replace(new Term(",", [ + new Term("call", [cond]), + new Term(",", [new Term("!"), then]) + ])); + thread.prepend([new State(goal, point.substitution, point)]); + }, + "*->/2": function(thread, point, atom) { + var cond = atom.args[0], then = atom.args[1]; + var goal = point.goal.replace(new Term(",", [ + new Term("call", [cond]), + then + ])); + thread.prepend([new State(goal, point.substitution, point)]); + }, + "fail/0": function(_1, _2, _3) { + }, + "false/0": function(_1, _2, _3) { + }, + "true/0": function(thread, point, _) { + thread.success(point); + }, + "call/1": callN(1), + "call/2": callN(2), + "call/3": callN(3), + "call/4": callN(4), + "call/5": callN(5), + "call/6": callN(6), + "call/7": callN(7), + "call/8": callN(8), + "once/1": function(thread, point, atom) { + var goal = atom.args[0]; + thread.prepend([new State(point.goal.replace(new Term(",", [new Term("call", [goal]), new Term("!", [])])), point.substitution, point)]); + }, + "forall/2": function(thread, point, atom) { + var generate = atom.args[0], test = atom.args[1]; + thread.prepend([new State(point.goal.replace(new Term("\\+", [new Term(",", [new Term("call", [generate]), new Term("\\+", [new Term("call", [test])])])])), point.substitution, point)]); + }, + "repeat/0": function(thread, point, _) { + thread.prepend([new State(point.goal.replace(null), point.substitution, point), point]); + }, + "throw/1": function(thread, point, atom) { + var error = atom.args[0]; + if (pl.type.is_variable(error)) { + thread.throw_error(pl.error.instantiation(thread.level.indicator)); + } else { + for (var i2 = 0; i2 < thread.points.length; i2++) { + var state = thread.points[i2]; + if (state.setup_call_cleanup_catch) { + thread.points = [new State( + new Term(",", [ + new Term("catch", [ + state.setup_call_cleanup_catch, + new Var("_"), + new Term("throw", [error]) + ]), + new Term("throw", [error]) + ]), + point.substitution, + point + )]; + return; + } + } + thread.throw_error(error); + } + }, + "catch/3": function(thread, point, atom) { + var goal = atom.args[0], catcher = atom.args[1], recover = atom.args[2]; + var nthread; + if (!point.catch) { + nthread = new Thread(thread.session); + nthread.debugger = thread.debugger; + nthread.format_success = function(state) { + return state.substitution; + }; + nthread.format_error = function(state) { + return state.goal; + }; + nthread.add_goal(goal, true, point); + point.catch = nthread; + } else { + nthread = point.catch; + } + var callback = function(answer) { + if (pl.type.is_error(answer)) { + var occurs_check = thread.get_flag("occurs_check").indicator === "true/0"; + var state = new State(); + var mgu = pl.unify(answer.args[0], catcher, occurs_check); + if (mgu !== null) { + state.substitution = point.substitution.apply(mgu); + state.goal = point.goal.replace(recover).apply(mgu); + state.parent = point; + thread.prepend([state]); + } else { + thread.throw_error(answer.args[0]); + } + } else if (answer !== false && answer !== null) { + var state = answer === null ? [] : new State( + point.goal.apply(answer).replace(null), + point.substitution.apply(answer), + point + ); + thread.prepend([state, point]); + } else if (answer === null) { + thread.prepend([point]); + if (thread.has_limit) + thread.current_limit = 0; + } + thread.again(answer !== null); + }; + nthread.answer(callback); + return true; + }, + "call_cleanup/2": function(thread, point, atom) { + var call = atom.args[0], cleanup = atom.args[1]; + if (pl.type.is_variable(call) || pl.type.is_variable(cleanup)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(call)) { + thread.throw_error(pl.error.type("callable", call, atom.indicator)); + } else if (!pl.type.is_callable(cleanup)) { + thread.throw_error(pl.error.type("callable", cleanup, atom.indicator)); + } else { + var nthread, callback; + if (point.hasOwnProperty("setup_call_cleanup_thread")) { + nthread = point.setup_call_cleanup_thread; + callback = point.setup_call_cleanup_callback; + } else { + var goal = new Term("call", [call]); + nthread = new Thread(thread.session); + nthread.add_goal(goal, true, point); + callback = function(answer) { + if (answer === null) { + var state = new State( + point.goal, + point.substitution, + point + ); + state.setup_call_cleanup_thread = nthread; + state.setup_call_cleanup_callback = callback; + thread.prepend([state]); + } else if (answer === false) { + var cleanup_and_fail = new Term(",", [ + new Term("call", [cleanup]), + new Term("fail") + ]); + var state = new State( + point.goal.replace(cleanup_and_fail), + point.substitution, + point + ); + thread.prepend([state]); + } else if (pl.type.is_error(answer)) { + var cleanup_and_throw = new Term(",", [ + new Term("call", [cleanup]), + answer + ]); + var state = new State( + point.goal.replace(cleanup_and_throw), + point.substitution, + point + ); + thread.prepend([state]); + } else { + if (nthread.points.length === 0) { + var state = new State( + point.goal.replace( + new Term("call", [cleanup]) + ).apply(answer), + point.substitution.apply(answer), + point + ); + thread.prepend([state]); + } else { + var state1 = new State( + point.goal.apply(answer).replace(null), + point.substitution.apply(answer), + point + ); + var state2 = new State( + point.goal, + point.substitution, + point + ); + state2.setup_call_cleanup_thread = nthread; + state2.setup_call_cleanup_callback = callback; + state2.setup_call_cleanup_goal = cleanup.apply(answer); + state2.setup_call_cleanup_catch = cleanup; + thread.prepend([state1, state2]); + } + } + thread.again(); + }; + } + nthread.answer(callback); + return true; + } + }, + "setup_call_cleanup/3": function(thread, point, atom) { + var setup = atom.args[0], call = atom.args[1], cleanup = atom.args[2]; + if (pl.type.is_variable(setup) || pl.type.is_variable(call) || pl.type.is_variable(cleanup)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(setup)) { + thread.throw_error(pl.error.type("callable", setup, atom.indicator)); + } else if (!pl.type.is_callable(call)) { + thread.throw_error(pl.error.type("callable", call, atom.indicator)); + } else if (!pl.type.is_callable(cleanup)) { + thread.throw_error(pl.error.type("callable", cleanup, atom.indicator)); + } else { + thread.prepend([new State( + point.goal.replace(new Term(",", [ + new Term("once", [setup]), + new Term("call_cleanup", [call, cleanup]) + ])), + point.substitution, + point + )]); + } + }, + "=/2": function(thread, point, atom) { + var occurs_check = thread.get_flag("occurs_check").indicator === "true/0"; + var state = new State(); + var mgu = pl.unify(atom.args[0], atom.args[1], occurs_check); + if (mgu !== null) { + state.goal = point.goal.apply(mgu).replace(null); + state.substitution = point.substitution.apply(mgu); + state.parent = point; + thread.prepend([state]); + } + }, + "unify_with_occurs_check/2": function(thread, point, atom) { + var state = new State(); + var mgu = pl.unify(atom.args[0], atom.args[1], true); + if (mgu !== null) { + state.goal = point.goal.apply(mgu).replace(null); + state.substitution = point.substitution.apply(mgu); + state.parent = point; + thread.prepend([state]); + } + }, + "\\=/2": function(thread, point, atom) { + var occurs_check = thread.get_flag("occurs_check").indicator === "true/0"; + var mgu = pl.unify(atom.args[0], atom.args[1], occurs_check); + if (mgu === null) { + thread.success(point); + } + }, + "subsumes_term/2": function(thread, point, atom) { + var general = atom.args[0], specific = atom.args[1]; + var vars1 = thread.next_free_variable(); + var vars2 = thread.next_free_variable(); + thread.prepend([new State( + point.goal.replace(new Term("\\+", [ + new Term("\\+", [ + new Term(",", [ + new Term("term_variables", [specific, vars1]), + new Term(",", [ + new Term("unify_with_occurs_check", [general, specific]), + new Term(",", [ + new Term("term_variables", [vars1, vars2]), + new Term("==", [vars1, vars2]) + ]) + ]) + ]) + ]) + ])), + point.substitution, + point + )]); + }, + "findall/3": function(thread, point, atom) { + var template = atom.args[0], goal = atom.args[1], instances = atom.args[2]; + var tail = new Term("[]", []); + thread.prepend([new State( + point.goal.replace(new Term("findall", [template, goal, instances, tail])), + point.substitution, + point + )]); + }, + "findall/4": function(thread, point, atom) { + var template = atom.args[0], goal = atom.args[1], instances = atom.args[2], tail = atom.args[3]; + var proper_goal = goal; + if (pl.type.is_term(goal) && goal.indicator === ":/2") + proper_goal = goal.args[1]; + if (pl.type.is_variable(proper_goal)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(proper_goal)) { + thread.throw_error(pl.error.type("callable", goal, atom.indicator)); + } else if (!pl.type.is_variable(instances) && !pl.type.is_list(instances)) { + thread.throw_error(pl.error.type("list", instances, atom.indicator)); + } else if (!pl.type.is_variable(tail) && !pl.type.is_list(tail)) { + thread.throw_error(pl.error.type("list", tail, atom.indicator)); + } else { + thread.prepend([new State( + point.goal.replace(new Term("$findall", [template, goal, instances, tail])), + point.substitution, + point + )]); + } + }, + "bagof/3": function(thread, point, atom) { + var template = atom.args[0], goal = atom.args[1], instances = atom.args[2]; + if (pl.type.is_variable(goal)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(goal)) { + thread.throw_error(pl.error.type("callable", goal, atom.indicator)); + } else if (!pl.type.is_variable(instances) && !pl.type.is_list(instances)) { + thread.throw_error(pl.error.type("list", instances, atom.indicator)); + } else { + thread.prepend([new State( + point.goal.replace(new Term("$bagof", [template, goal, instances])), + point.substitution, + point + )]); + } + }, + "setof/3": function(thread, point, atom) { + var template = atom.args[0], goal = atom.args[1], instances = atom.args[2]; + if (pl.type.is_variable(goal)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(goal)) { + thread.throw_error(pl.error.type("callable", goal, atom.indicator)); + } else if (!pl.type.is_variable(instances) && !pl.type.is_list(instances)) { + thread.throw_error(pl.error.type("list", instances, atom.indicator)); + } else { + thread.prepend([new State( + point.goal.replace(new Term("$setof", [template, goal, instances])), + point.substitution, + point + )]); + } + }, + "functor/3": function(thread, point, atom) { + var subs; + var term = atom.args[0], name = atom.args[1], arity = atom.args[2]; + if (pl.type.is_variable(term) && (pl.type.is_variable(name) || pl.type.is_variable(arity))) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(arity) && !pl.type.is_integer(arity)) { + thread.throw_error(pl.error.type("integer", atom.args[2], atom.indicator)); + } else if (!pl.type.is_variable(name) && !pl.type.is_atomic(name)) { + thread.throw_error(pl.error.type("atomic", atom.args[1], atom.indicator)); + } else if (pl.type.is_variable(term) && !pl.type.is_atom(name) && pl.type.is_integer(arity) && arity.value > 0) { + thread.throw_error(pl.error.type("atom", atom.args[1], atom.indicator)); + } else if (pl.type.is_variable(term) && pl.type.is_integer(arity) && arity.value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", atom.args[2], atom.indicator)); + } else if (pl.type.is_variable(term)) { + if (atom.args[2].value >= 0) { + var args = []; + for (var i2 = 0; i2 < arity.value; i2++) + args.push(thread.next_free_variable()); + var functor = pl.type.is_number(name) ? name : new Term(name.id, args); + thread.prepend([new State(point.goal.replace(new Term("=", [term, functor])), point.substitution, point)]); + } + } else { + var id = pl.type.is_number(term) ? term : new Term(term.id, []); + var length = pl.type.is_number(term) ? new Num(0, false) : new Num(term.args.length, false); + var goal = new Term(",", [new Term("=", [id, name]), new Term("=", [length, arity])]); + thread.prepend([new State(point.goal.replace(goal), point.substitution, point)]); + } + }, + "arg/3": function(thread, point, atom) { + if (pl.type.is_variable(atom.args[0]) || pl.type.is_variable(atom.args[1])) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(atom.args[0])) { + thread.throw_error(pl.error.type("integer", atom.args[0], atom.indicator)); + } else if (atom.args[0].value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", atom.args[0], atom.indicator)); + } else if (!pl.type.is_compound(atom.args[1])) { + thread.throw_error(pl.error.type("compound", atom.args[1], atom.indicator)); + } else { + var n = atom.args[0].value; + if (n > 0 && n <= atom.args[1].args.length) { + var goal = new Term("=", [atom.args[1].args[n - 1], atom.args[2]]); + thread.prepend([new State(point.goal.replace(goal), point.substitution, point)]); + } + } + }, + "=../2": function(thread, point, atom) { + var list; + if (pl.type.is_variable(atom.args[0]) && (pl.type.is_variable(atom.args[1]) || pl.type.is_non_empty_list(atom.args[1]) && pl.type.is_variable(atom.args[1].args[0]))) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_fully_list(atom.args[1])) { + thread.throw_error(pl.error.type("list", atom.args[1], atom.indicator)); + } else if (pl.type.is_variable(atom.args[0]) && pl.type.is_empty_list(atom.args[1])) { + thread.throw_error(pl.error.domain("non_empty_list", atom.args[1], atom.indicator)); + } else if (!pl.type.is_variable(atom.args[0])) { + if (pl.type.is_term(atom.args[0]) && atom.args[0].args.length > 0) { + list = new Term("[]"); + for (var i2 = atom.args[0].args.length - 1; i2 >= 0; i2--) { + list = new Term(".", [atom.args[0].args[i2], list]); + } + list = new Term(".", [new Term(atom.args[0].id), list]); + } else { + list = new Term(".", [atom.args[0], new Term("[]")]); + } + thread.prepend([new State(point.goal.replace(new Term("=", [list, atom.args[1]])), point.substitution, point)]); + } else if (!pl.type.is_variable(atom.args[1])) { + var args = []; + list = atom.args[1].args[1]; + while (list.indicator === "./2") { + args.push(list.args[0]); + list = list.args[1]; + } + if (pl.type.is_variable(atom.args[0]) && pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (args.length === 0 && pl.type.is_compound(atom.args[1].args[0])) { + thread.throw_error(pl.error.type("atomic", atom.args[1].args[0], atom.indicator)); + } else if (args.length > 0 && (pl.type.is_compound(atom.args[1].args[0]) || pl.type.is_number(atom.args[1].args[0]))) { + thread.throw_error(pl.error.type("atom", atom.args[1].args[0], atom.indicator)); + } else { + if (args.length === 0) { + thread.prepend([new State(point.goal.replace(new Term("=", [atom.args[1].args[0], atom.args[0]], point)), point.substitution, point)]); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [new Term(atom.args[1].args[0].id, args), atom.args[0]])), point.substitution, point)]); + } + } + } + }, + "copy_term/2": function(thread, point, atom) { + var original_term = atom.args[0], renamed_term = atom.args[1]; + thread.session.renamed_variables = {}; + var new_term = original_term.rename(thread); + thread.session.renamed_variables = {}; + thread.prepend( + [ + new State( + point.goal.replace(new Term("=", [renamed_term, new_term])), + point.substitution, + point + ) + ] + ); + }, + "term_variables/2": [ + new pl.type.Rule(new pl.type.Term("term_variables", [new pl.type.Var("Term"), new pl.type.Var("Vars")]), new pl.type.Term("term_variables", [new pl.type.Var("Term"), new pl.type.Var("Vars"), new pl.type.Term("[]", [])])) + ], + "term_variables/3": function(thread, point, atom) { + var term = atom.args[0], vars = atom.args[1], tail = atom.args[2]; + if (!pl.type.is_fully_list(vars)) { + thread.throw_error(pl.error.type("list", vars, atom.indicator)); + } else { + var list = arrayToList(map(nub(term.variables()), function(v) { + return new Var(v); + }), tail); + thread.prepend([new State( + point.goal.replace(new Term("=", [vars, list])), + point.substitution, + point + )]); + } + }, + "numbervars/3": function(thread, point, atom) { + var term = atom.args[0], start = atom.args[1], end = atom.args[2]; + if (pl.type.is_variable(start)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(start)) { + thread.throw_error(pl.error.type("integer", start, atom.indicator)); + } else if (!pl.type.is_variable(end) && !pl.type.is_integer(end)) { + thread.throw_error(pl.error.type("integer", end, atom.indicator)); + } else { + var variables = nub(term.variables()); + var value = start.value; + var unif_body = new Term("true"); + for (var i2 = 0; i2 < variables.length; i2++) { + unif_body = new Term(",", [ + new Term("=", [ + new Var(variables[i2]), + new Term("$VAR", [new Num(value, false)]) + ]), + unif_body + ]); + value++; + } + var unif_end = new Term("=", [end, new Num(value, false)]); + if (pl.type.is_variable(end) || end.value === value) { + thread.prepend([new State( + point.goal.replace(new Term(",", [unif_body, unif_end])), + point.substitution, + point + )]); + } + } + }, + "clause/2": function(thread, point, atom) { + var head = atom.args[0], body = atom.args[1]; + var module_id = "user"; + if (pl.type.is_term(head) && head.indicator === ":/2") { + if (!pl.type.is_atom(head.args[0])) { + thread.throw_error(pl.error.type("module", head.args[0], atom.indicator)); + return; + } + module_id = head.args[0].id; + head = head.args[1]; + } + var get_module = thread.session.modules[module_id]; + if (pl.type.is_variable(head)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(head)) { + thread.throw_error(pl.error.type("callable", head, atom.indicator)); + } else if (!pl.type.is_variable(body) && !pl.type.is_callable(body)) { + thread.throw_error(pl.error.type("callable", body, atom.indicator)); + } else if (head.indicator === ",/2" || thread.session.modules.system.rules.hasOwnProperty(head.indicator)) { + thread.throw_error(pl.error.permission("access", "private_procedure", str_indicator(head.indicator), atom.indicator)); + } else if (pl.type.is_module(get_module) && get_module.rules[head.indicator]) { + if (get_module.is_public_predicate(head.indicator)) { + var states = []; + if (typeof get_module.rules[head.indicator] === "function") { + thread.throw_error(pl.error.permission("modify", "static_procedure", str_indicator(head.indicator), atom.indicator)); + return; + } + for (var i2 = 0; i2 < get_module.rules[head.indicator].length; i2++) { + var rule = get_module.rules[head.indicator][i2]; + thread.session.renamed_variables = {}; + rule = rule.rename(thread); + if (rule.body === null) + rule.body = new Term("true"); + var goal = new Term(",", [ + new Term("=", [rule.head, head]), + new Term("=", [rule.body, body]) + ]); + states.push(new State(point.goal.replace(goal), point.substitution, point)); + } + thread.prepend(states); + } else { + thread.throw_error(pl.error.permission("access", "private_procedure", str_indicator(head.indicator), atom.indicator)); + } + } + }, + "current_predicate/1": function(thread, point, atom) { + var indicator2 = atom.args[0]; + var module_id; + if (pl.type.is_term(indicator2) && indicator2.indicator === ":/2") { + if (!pl.type.is_atom(indicator2.args[0])) { + thread.throw_error(pl.error.type("module", indicator2.args[0], atom.indicator)); + return; + } + module_id = indicator2.args[0].id; + indicator2 = indicator2.args[1]; + } else { + module_id = "user"; + } + if (!pl.type.is_variable(indicator2) && (!pl.type.is_compound(indicator2) || indicator2.indicator !== "//2")) { + thread.throw_error(pl.error.type("predicate_indicator", indicator2, atom.indicator)); + } else if (!pl.type.is_variable(indicator2) && !pl.type.is_variable(indicator2.args[0]) && !pl.type.is_atom(indicator2.args[0])) { + thread.throw_error(pl.error.type("atom", indicator2.args[0], atom.indicator)); + } else if (!pl.type.is_variable(indicator2) && !pl.type.is_variable(indicator2.args[1]) && !pl.type.is_integer(indicator2.args[1])) { + thread.throw_error(pl.error.type("integer", indicator2.args[1], atom.indicator)); + } else if (!pl.type.is_variable(indicator2) && pl.type.is_integer(indicator2.args[1]) && indicator2.args[1].value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", indicator2.args[1], atom.indicator)); + } else { + var states = []; + var get_module = thread.session.modules[module_id]; + if (pl.type.is_module(get_module)) { + for (var prop in get_module.rules) { + if (!get_module.rules.hasOwnProperty(prop)) + continue; + var predicate = str_indicator(prop); + var goal = new Term("=", [predicate, indicator2]); + states.push(new State(point.goal.replace(goal), point.substitution, point)); + } + thread.prepend(states); + } + } + }, + "current_module/1": function(thread, point, atom) { + var module_id = atom.args[0]; + if (!pl.type.is_variable(module_id) && !pl.type.is_atom(module_id)) { + thread.throw_error(pl.error.type("atom", module_id, atom.indicator)); + } else { + if (pl.type.is_variable(module_id)) { + var states = []; + for (var prop in thread.session.modules) { + if (!thread.session.modules.hasOwnProperty(prop)) + continue; + states.push(new State( + point.goal.replace(new Term("=", [module_id, new Term(prop)])), + point.substitution, + point + )); + } + thread.prepend(states); + } else { + if (thread.session.modules.hasOwnProperty(module_id.id)) + thread.success(point); + } + } + }, + "predicate_property/2": function(thread, point, atom) { + var head = atom.args[0], property = atom.args[1]; + var module_id; + if (pl.type.is_term(head) && head.indicator === ":/2") { + if (!pl.type.is_atom(head.args[0])) { + thread.throw_error(pl.error.type("module", head.args[0], atom.indicator)); + return; + } + module_id = head.args[0].id; + head = head.args[1]; + } + if (!pl.type.is_variable(head) && !pl.type.is_callable(head)) { + thread.throw_error(pl.error.type("callable", head, atom.indicator)); + } else if (!pl.type.is_variable(property) && !pl.type.is_predicate_property(property)) { + thread.throw_error(pl.error.domain("predicate_property", property, atom.indicator)); + } else { + var get_module = module_id ? thread.session.modules[module_id] : thread.session.modules.user; + var points = []; + if (pl.type.is_variable(head)) { + if (!module_id) { + for (var prop in pl.builtin.rules) { + if (!pl.builtin.rules.hasOwnProperty(prop)) + continue; + var indicator2 = str_indicator(prop); + var args = []; + for (var i2 = 0; i2 < indicator2.args[1].value; i2++) + args.push(thread.next_free_variable()); + var unif_head = new Term(indicator2.args[0].id, args); + var current_properties = [ + new Term("static"), + new Term("built_in"), + new Term("native_code") + ]; + if (pl.builtin.meta_predicates.hasOwnProperty(prop)) + current_properties.push(new Term("meta_predicate", [ + pl.builtin.meta_predicates[prop] + ])); + for (var i2 = 0; i2 < current_properties.length; i2++) { + if (pl.type.is_variable(property) || current_properties[i2].indicator === property.indicator) { + points.push(new State( + point.goal.replace(new Term(",", [ + new Term("=", [head, unif_head]), + new Term("=", [property, current_properties[i2]]) + ])), + point.substitution, + point + )); + } + } + } + } + if (pl.type.is_module(get_module)) { + for (var prop in get_module.rules) { + if (!get_module.rules.hasOwnProperty(prop)) + continue; + var indicator2 = str_indicator(prop); + var args = []; + for (var i2 = 0; i2 < indicator2.args[1].value; i2++) + args.push(thread.next_free_variable()); + var unif_head = new Term(indicator2.args[0].id, args); + var current_properties = []; + if (thread.is_public_predicate(prop, module_id)) + current_properties.push(new Term("dynamic")); + else + current_properties.push(new Term("static")); + if (get_module.rules[prop] instanceof Function) + current_properties.push(new Term("native_code")); + if (thread.is_multifile_predicate(prop, module_id)) + current_properties.push(new Term("multifile")); + if (get_module.meta_predicates.hasOwnProperty(prop)) + current_properties.push(new Term("meta_predicate", [ + get_module.meta_predicates[prop] + ])); + for (var i2 = 0; i2 < current_properties.length; i2++) { + if (pl.type.is_variable(property) || current_properties[i2].indicator === property.indicator) { + points.push(new State( + point.goal.replace(new Term(",", [ + new Term("=", [head, unif_head]), + new Term("=", [property, current_properties[i2]]) + ])), + point.substitution, + point + )); + } + } + } + } + } else { + var builtin = !module_id && pl.type.is_builtin(head); + var predicate = builtin ? pl.builtin.rules[head.indicator] : get_module.rules[head.indicator]; + get_module = builtin ? pl.builtin : get_module; + if (predicate) { + var current_properties; + if (builtin) { + current_properties = [ + new Term("static"), + new Term("built_in"), + new Term("native_code") + ]; + } else { + current_properties = []; + if (thread.is_public_predicate(head.indicator, module_id)) + current_properties.push(new Term("dynamic")); + else + current_properties.push(new Term("static")); + if (predicate instanceof Function) + current_properties.push(new Term("native_code")); + if (thread.is_multifile_predicate(head.indicator, module_id)) + current_properties.push(new Term("multifile")); + } + if (get_module.meta_predicates.hasOwnProperty(head.indicator)) + current_properties.push(new Term("meta_predicate", [ + get_module.meta_predicates[head.indicator] + ])); + var args = []; + for (var i2 = 0; i2 < head.args.length; i2++) + args.push(thread.next_free_variable()); + var unif_head = new Term(head.id, args); + for (var i2 = 0; i2 < current_properties.length; i2++) { + if (pl.type.is_variable(property) || current_properties[i2].indicator === property.indicator) { + points.push(new State( + point.goal.replace(new Term(",", [ + new Term("=", [head, unif_head]), + new Term("=", [property, current_properties[i2]]) + ])), + point.substitution, + point + )); + } + } + } + } + thread.prepend(points); + } + }, + "listing/0": function(thread, point, atom) { + var context_module = atom.context_module ? atom.context_module : "user"; + var rules2 = {}; + if (pl.type.is_module(thread.session.modules[context_module])) { + rules2 = thread.session.modules[context_module].rules; + } + var str = ""; + for (var indicator2 in rules2) { + if (!rules2.hasOwnProperty(indicator2)) + continue; + var predicate = rules2[indicator2]; + str += "% " + indicator2 + "\n"; + if (predicate instanceof Array) { + for (var i2 = 0; i2 < predicate.length; i2++) + str += predicate[i2].toString({ session: thread.session }) + "\n"; + } else { + str += "/*\n" + predicate.toString() + "\n*/"; + } + str += "\n"; + } + thread.prepend([new State( + point.goal.replace(new Term("write", [new Term(str, [])])), + point.substitution, + point + )]); + }, + "listing/1": function(thread, point, atom) { + var indicator2 = atom.args[0]; + var context_module = "user"; + if (indicator2.indicator === ":/2") { + context_module = indicator2.args[0].id; + indicator2 = indicator2.args[1]; + } + if (pl.type.is_variable(indicator2)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_predicate_indicator(indicator2)) { + thread.throw_error(pl.error.type("predicate_indicator", indicator2, atom.indicator)); + } else { + var rules2 = {}; + if (pl.type.is_module(thread.session.modules[context_module])) { + rules2 = thread.session.modules[context_module].rules; + } + var str = ""; + var str_indicator2 = indicator2.args[0].id + "/" + indicator2.args[1].value; + if (rules2.hasOwnProperty(str_indicator2)) { + var predicate = rules2[str_indicator2]; + if (predicate instanceof Array) { + for (var i2 = 0; i2 < predicate.length; i2++) + str += predicate[i2].toString({ session: thread.session }) + "\n"; + } else { + str += "/*\n" + predicate.toString() + "\n*/"; + } + str += "\n"; + } + thread.prepend([new State( + point.goal.replace(new Term("write", [new Term(str, [])])), + point.substitution, + point + )]); + } + }, + "sort/2": function(thread, point, atom) { + var list = atom.args[0], expected = atom.args[1]; + if (pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(expected) && !pl.type.is_fully_list(expected)) { + thread.throw_error(pl.error.type("list", expected, atom.indicator)); + } else { + var arr = []; + var pointer = list; + while (pointer.indicator === "./2") { + arr.push(pointer.args[0]); + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_empty_list(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + var sorted_arr = arr.sort(pl.compare); + for (var i2 = sorted_arr.length - 1; i2 > 0; i2--) { + if (sorted_arr[i2].equals(sorted_arr[i2 - 1])) + sorted_arr.splice(i2, 1); + } + var sorted_list = new Term("[]"); + for (var i2 = sorted_arr.length - 1; i2 >= 0; i2--) { + sorted_list = new Term(".", [sorted_arr[i2], sorted_list]); + } + thread.prepend([new State(point.goal.replace(new Term("=", [sorted_list, expected])), point.substitution, point)]); + } + } + }, + "keysort/2": function(thread, point, atom) { + var list = atom.args[0], expected = atom.args[1]; + if (pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(expected) && !pl.type.is_fully_list(expected)) { + thread.throw_error(pl.error.type("list", expected, atom.indicator)); + } else { + var arr = []; + var elem; + var pointer = list; + while (pointer.indicator === "./2") { + elem = pointer.args[0]; + if (pl.type.is_variable(elem)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_term(elem) || elem.indicator !== "-/2") { + thread.throw_error(pl.error.type("pair", elem, atom.indicator)); + return; + } + elem.args[0].pair = elem.args[1]; + arr.push(elem.args[0]); + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_empty_list(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + if (!pl.type.is_variable(expected)) { + var pointer = expected; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var head = pointer.args[0]; + if (!pl.type.is_variable(head) && (!pl.type.is_term(head) || head.indicator !== "-/2")) { + thread.throw_error(pl.error.type("pair", head, atom.indicator)); + return; + } + pointer = pointer.args[1]; + } + if (!pl.type.is_variable(pointer) && !pl.type.is_empty_list(pointer)) { + thread.throw_error(pl.error.type("list", expected, atom.indicator)); + return; + } + } + var sorted_arr = arr.sort(pl.compare); + var sorted_list = new pl.type.Term("[]"); + for (var i2 = sorted_arr.length - 1; i2 >= 0; i2--) { + sorted_list = new pl.type.Term(".", [new pl.type.Term("-", [sorted_arr[i2], sorted_arr[i2].pair]), sorted_list]); + delete sorted_arr[i2].pair; + } + thread.prepend([new pl.type.State(point.goal.replace(new pl.type.Term("=", [sorted_list, expected])), point.substitution, point)]); + } + } + }, + "keygroup/2": function(thread, point, atom) { + var list = atom.args[0], expected = atom.args[1]; + if (pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(expected) && !pl.type.is_fully_list(expected)) { + thread.throw_error(pl.error.type("list", expected, atom.indicator)); + } else { + var keys = []; + var values = []; + var pointer = list; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var elem = pointer.args[0]; + if (pl.type.is_variable(elem)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_term(elem) || elem.indicator !== "-/2") { + thread.throw_error(pl.error.type("pair", elem, atom.indicator)); + return; + } + var key = elem.args[0], value = elem.args[1]; + var index = -1; + for (var i2 = 0; i2 < keys.length; i2++) { + if (pl.compare(key, keys[i2]) === 0) { + index = i2; + break; + } + } + if (index === -1) { + index = keys.length; + keys.push(key); + values.push([]); + } + values[index].push(value); + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_empty_list(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + if (!pl.type.is_variable(expected)) { + var pointer = expected; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + var head = pointer.args[0]; + if (!pl.type.is_variable(head) && (!pl.type.is_term(head) || head.indicator !== "-/2")) { + thread.throw_error(pl.error.type("pair", head, atom.indicator)); + return; + } + pointer = pointer.args[1]; + } + if (!pl.type.is_variable(pointer) && !pl.type.is_empty_list(pointer)) { + thread.throw_error(pl.error.type("list", expected, atom.indicator)); + return; + } + } + group = new Term("[]", []); + for (var i2 = keys.length - 1; i2 >= 0; i2--) + group = new Term(".", [new Term("-", [keys[i2], arrayToList(values[i2])]), group]); + thread.prepend([ + new State( + point.goal.replace(new pl.type.Term("=", [expected, group])), + point.substitution, + point + ) + ]); + } + } + }, + "asserta/1": function(thread, point, atom) { + var clause = atom.args[0]; + var module_id = "user"; + if (pl.type.is_term(clause) && clause.indicator === ":/2") { + module_id = clause.args[0].id; + clause = clause.args[1]; + } + if (pl.type.is_variable(clause)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(clause)) { + thread.throw_error(pl.error.type("callable", clause, atom.indicator)); + } else { + var head, body, get_module; + if (clause.indicator === ":-/2") { + head = clause.args[0]; + body = body_conversion(clause.args[1]); + } else { + head = clause; + body = null; + } + if (pl.type.is_variable(head)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(head)) { + thread.throw_error(pl.error.type("callable", head, atom.indicator)); + } else if (body !== null && !pl.type.is_callable(body)) { + thread.throw_error(pl.error.type("callable", body, atom.indicator)); + } else if ((!pl.type.is_module(thread.session.modules[module_id]) || thread.is_public_predicate(head.indicator, module_id)) && head.indicator !== ",/2" && !thread.session.modules.system.rules.hasOwnProperty(head.indicator)) { + if (!pl.type.is_module(thread.session.modules[module_id])) { + get_module = new Module(module_id, {}, "all", { session: thread.session }); + thread.session.modules[module_id] = get_module; + } else { + get_module = thread.session.modules[module_id]; + } + if (get_module.rules[head.indicator] === void 0) + get_module.rules[head.indicator] = []; + get_module.public_predicates[head.indicator] = true; + get_module.rules[head.indicator] = [new Rule(head, body, true)].concat(get_module.rules[head.indicator]); + get_module.update_indices_predicate(head.indicator); + thread.success(point); + } else { + thread.throw_error(pl.error.permission("modify", "static_procedure", str_indicator(head.indicator), atom.indicator)); + } + } + }, + "assertz/1": function(thread, point, atom) { + var clause = atom.args[0]; + var module_id = "user"; + if (pl.type.is_term(clause) && clause.indicator === ":/2") { + module_id = clause.args[0].id; + clause = clause.args[1]; + } + if (pl.type.is_variable(clause)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(clause)) { + thread.throw_error(pl.error.type("callable", clause, atom.indicator)); + } else { + var head, body, get_module; + if (clause.indicator === ":-/2") { + head = clause.args[0]; + body = body_conversion(clause.args[1]); + } else { + head = clause; + body = null; + } + if (pl.type.is_variable(head)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(head)) { + thread.throw_error(pl.error.type("callable", head, atom.indicator)); + } else if (body !== null && !pl.type.is_callable(body)) { + thread.throw_error(pl.error.type("callable", body, atom.indicator)); + } else if ((!pl.type.is_module(thread.session.modules[module_id]) || thread.is_public_predicate(head.indicator, module_id)) && head.indicator !== ",/2" && !thread.session.modules.system.rules.hasOwnProperty(head.indicator)) { + if (!pl.type.is_module(thread.session.modules[module_id])) { + get_module = new Module(module_id, {}, "all", { session: thread.session }); + thread.session.modules[module_id] = get_module; + } else { + get_module = thread.session.modules[module_id]; + } + if (get_module.rules[head.indicator] === void 0) + get_module.rules[head.indicator] = []; + get_module.public_predicates[head.indicator] = true; + get_module.rules[head.indicator].push(new Rule(head, body, true)); + get_module.update_indices_predicate(head.indicator); + thread.success(point); + } else { + thread.throw_error(pl.error.permission("modify", "static_procedure", str_indicator(head.indicator), atom.indicator)); + } + } + }, + "retract/1": function(thread, point, atom) { + var clause = atom.args[0]; + if (pl.type.is_variable(clause)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(clause)) { + thread.throw_error(pl.error.type("callable", clause, atom.indicator)); + } else { + var head, body, module_atom, module_id; + if (clause.indicator === ":/2") { + module_atom = clause.args[0]; + clause = clause.args[1]; + if (!pl.type.is_atom(module_atom)) { + thread.throw_error(pl.error.type("module", module_atom, atom.indicator)); + return; + } + } else { + module_atom = new Term("user"); + } + if (clause.indicator === ":-/2") { + head = clause.args[0]; + body = clause.args[1]; + } else { + head = clause; + body = new Term("true"); + } + if (pl.type.is_variable(head)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_callable(head)) { + thread.throw_error(pl.error.type("callable", head, atom.indicator)); + return; + } + module_id = module_atom.id; + var get_module = thread.session.modules[module_id]; + if (!pl.type.is_module(get_module)) + return; + if (!point.retract) { + if (thread.is_public_predicate(head.indicator, module_id) && head.indicator !== ",/2" && !thread.session.modules.system.rules.hasOwnProperty(head.indicator)) { + if (get_module.rules[head.indicator] !== void 0) { + var states = []; + if (typeof get_module.rules[head.indicator] === "function") { + thread.throw_error(pl.error.permission("modify", "static_procedure", str_indicator(head.indicator), atom.indicator)); + return; + } + for (var i2 = 0; i2 < get_module.rules[head.indicator].length; i2++) { + thread.session.renamed_variables = {}; + var orule = get_module.rules[head.indicator][i2]; + var rule = orule.rename(thread); + if (rule.body === null) + rule.body = new Term("true", []); + var occurs_check = thread.get_flag("occurs_check").indicator === "true/0"; + var mgu = pl.unify(new Term(",", [head, body]), new Term(",", [rule.head, rule.body]), occurs_check); + if (mgu !== null) { + var state = new State( + point.goal.replace(new Term(",", [ + new Term(":", [ + module_atom, + new Term("retract", [new Term(":-", [head, body])]) + ]), + new Term(",", [ + new Term("=", [head, rule.head]), + new Term("=", [body, rule.body]) + ]) + ])), + point.substitution, + point + ); + state.retract = orule; + states.push(state); + } + } + thread.prepend(states); + } + } else { + thread.throw_error(pl.error.permission("modify", "static_procedure", str_indicator(head.indicator), atom.indicator)); + } + } else { + retract(thread, point, head.indicator, point.retract, get_module); + } + } + }, + "retractall/1": function(thread, point, atom) { + var head = atom.args[0]; + var context_module = "user"; + if (pl.type.is_term(head) && head.indicator === ":/2") { + context_module = head.args[0].id; + head = head.args[1]; + } + if (pl.type.is_variable(head)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(head)) { + thread.throw_error(pl.error.type("callable", head, atom.indicator)); + } else if (!thread.is_public_predicate(head.indicator, context_module) || head.indicator === ",/2" || thread.session.modules.system.rules.hasOwnProperty(head.indicator)) { + thread.throw_error(pl.error.permission("modify", "static_procedure", str_indicator(head.indicator), atom.indicator)); + } else { + thread.prepend([ + new State(point.goal.replace(new Term(",", [ + new Term(":", [ + new Term(context_module), + new Term("retract", [new pl.type.Term(":-", [head, new Var("_")])]) + ]), + new Term("fail", []) + ])), point.substitution, point), + new State(point.goal.replace(null), point.substitution, point) + ]); + } + }, + "abolish/1": function(thread, point, atom) { + var predicate = atom.args[0]; + var module_id; + if (pl.type.is_term(predicate) && predicate.indicator === ":/2") { + if (!pl.type.is_atom(predicate.args[0])) { + thread.throw_error(pl.error.type("module", predicate.args[0], atom.indicator)); + return; + } + module_id = predicate.args[0].id; + predicate = predicate.args[1]; + } else { + module_id = "user"; + } + if (pl.type.is_variable(predicate) || pl.type.is_term(predicate) && predicate.indicator === "//2" && (pl.type.is_variable(predicate.args[0]) || pl.type.is_variable(predicate.args[1]))) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_term(predicate) || predicate.indicator !== "//2") { + thread.throw_error(pl.error.type("predicate_indicator", predicate, atom.indicator)); + } else if (!pl.type.is_atom(predicate.args[0])) { + thread.throw_error(pl.error.type("atom", predicate.args[0], atom.indicator)); + } else if (!pl.type.is_integer(predicate.args[1])) { + thread.throw_error(pl.error.type("integer", predicate.args[1], atom.indicator)); + } else if (predicate.args[1].value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", predicate.args[1], atom.indicator)); + } else if (pl.type.is_number(thread.get_flag("max_arity")) && predicate.args[1].value > thread.get_flag("max_arity").value) { + thread.throw_error(pl.error.representation("max_arity", atom.indicator)); + } else { + var get_module = thread.session.modules[module_id]; + if (pl.type.is_module(get_module)) { + var indicator2 = predicate.args[0].id + "/" + predicate.args[1].value; + if (thread.is_public_predicate(indicator2, module_id) && indicator2 !== ",/2" && !thread.session.modules.system.rules.hasOwnProperty(indicator2)) { + delete get_module.rules[indicator2]; + delete get_module.indexed_clauses[indicator2]; + delete get_module.non_indexable_clauses[indicator2]; + delete get_module.public_predicates[indicator2]; + delete get_module.multifile_predicates[indicator2]; + thread.success(point); + } else { + thread.throw_error(pl.error.permission("modify", "static_procedure", atom.args[0], atom.indicator)); + } + } else { + thread.success(point); + } + } + }, + "atom_length/2": function(thread, point, atom) { + if (pl.type.is_variable(atom.args[0])) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(atom.args[0])) { + thread.throw_error(pl.error.type("atom", atom.args[0], atom.indicator)); + } else if (!pl.type.is_variable(atom.args[1]) && !pl.type.is_integer(atom.args[1])) { + thread.throw_error(pl.error.type("integer", atom.args[1], atom.indicator)); + } else if (pl.type.is_integer(atom.args[1]) && atom.args[1].value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", atom.args[1], atom.indicator)); + } else { + var length = new Num(stringLength(atom.args[0].id), false); + thread.prepend([new State(point.goal.replace(new Term("=", [length, atom.args[1]])), point.substitution, point)]); + } + }, + "atom_concat/3": function(thread, point, atom) { + var str, goal, start = atom.args[0], end = atom.args[1], whole = atom.args[2]; + if (pl.type.is_variable(whole) && (pl.type.is_variable(start) || pl.type.is_variable(end))) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(start) && !pl.type.is_atom(start)) { + thread.throw_error(pl.error.type("atom", start, atom.indicator)); + } else if (!pl.type.is_variable(end) && !pl.type.is_atom(end)) { + thread.throw_error(pl.error.type("atom", end, atom.indicator)); + } else if (!pl.type.is_variable(whole) && !pl.type.is_atom(whole)) { + thread.throw_error(pl.error.type("atom", whole, atom.indicator)); + } else { + var v1 = pl.type.is_variable(start); + var v2 = pl.type.is_variable(end); + if (!v1 && !v2) { + goal = new Term("=", [whole, new Term(start.id + end.id)]); + thread.prepend([new State(point.goal.replace(goal), point.substitution, point)]); + } else if (v1 && !v2) { + str = whole.id.substr(0, whole.id.length - end.id.length); + if (str + end.id === whole.id) { + goal = new Term("=", [start, new Term(str)]); + thread.prepend([new State(point.goal.replace(goal), point.substitution, point)]); + } + } else if (v2 && !v1) { + str = whole.id.substr(start.id.length); + if (start.id + str === whole.id) { + goal = new Term("=", [end, new Term(str)]); + thread.prepend([new State(point.goal.replace(goal), point.substitution, point)]); + } + } else { + var states = []; + for (var i2 = 0; i2 <= whole.id.length; i2++) { + var atom1 = new Term(whole.id.substr(0, i2)); + var atom2 = new Term(whole.id.substr(i2)); + goal = new Term(",", [new Term("=", [atom1, start]), new Term("=", [atom2, end])]); + states.push(new State(point.goal.replace(goal), point.substitution, point)); + } + thread.prepend(states); + } + } + }, + "sub_atom/5": function(thread, point, atom) { + var i2, atom1 = atom.args[0], before = atom.args[1], length = atom.args[2], after = atom.args[3], subatom = atom.args[4]; + if (pl.type.is_variable(atom1)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(atom1)) { + thread.throw_error(pl.error.type("atom", atom1, atom.indicator)); + } else if (!pl.type.is_variable(before) && !pl.type.is_integer(before)) { + thread.throw_error(pl.error.type("integer", before, atom.indicator)); + } else if (!pl.type.is_variable(length) && !pl.type.is_integer(length)) { + thread.throw_error(pl.error.type("integer", length, atom.indicator)); + } else if (!pl.type.is_variable(after) && !pl.type.is_integer(after)) { + thread.throw_error(pl.error.type("integer", after, atom.indicator)); + } else if (pl.type.is_integer(before) && before.value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", before, atom.indicator)); + } else if (pl.type.is_integer(length) && length.value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", length, atom.indicator)); + } else if (pl.type.is_integer(after) && after.value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", after, atom.indicator)); + } else if (!pl.type.is_variable(subatom) && !pl.type.is_atom(subatom)) { + thread.throw_error(pl.error.type("atom", subatom, atom.indicator)); + } else { + var bs = [], ls = [], as = []; + if (pl.type.is_variable(before)) { + for (i2 = 0; i2 <= atom1.id.length; i2++) { + bs.push(i2); + } + } else { + bs.push(before.value); + } + if (pl.type.is_variable(length)) { + for (i2 = 0; i2 <= atom1.id.length; i2++) { + ls.push(i2); + } + } else { + ls.push(length.value); + } + if (pl.type.is_variable(after)) { + for (i2 = 0; i2 <= atom1.id.length; i2++) { + as.push(i2); + } + } else { + as.push(after.value); + } + var states = []; + for (var _i in bs) { + if (!bs.hasOwnProperty(_i)) + continue; + i2 = bs[_i]; + for (var _j in ls) { + if (!ls.hasOwnProperty(_j)) + continue; + var j = ls[_j]; + var k = atom1.id.length - i2 - j; + if (indexOf(as, k) !== -1) { + if (i2 + j + k === atom1.id.length) { + var str = atom1.id.substr(i2, j); + if (atom1.id === atom1.id.substr(0, i2) + str + atom1.id.substr(i2 + j, k)) { + var pl1 = new Term("=", [new Term(str), subatom]); + var pl2 = new Term("=", [before, new Num(i2)]); + var pl3 = new Term("=", [length, new Num(j)]); + var pl4 = new Term("=", [after, new Num(k)]); + var goal = new Term(",", [new Term(",", [new Term(",", [pl2, pl3]), pl4]), pl1]); + states.push(new State(point.goal.replace(goal), point.substitution, point)); + } + } + } + } + } + thread.prepend(states); + } + }, + "atom_chars/2": function(thread, point, atom) { + var atom1 = atom.args[0], list = atom.args[1]; + if (pl.type.is_variable(atom1) && pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(atom1) && !pl.type.is_atom(atom1)) { + thread.throw_error(pl.error.type("atom", atom1, atom.indicator)); + } else { + if (!pl.type.is_variable(atom1)) { + if (!pl.type.is_variable(list)) { + var pointer = list; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + if (!pl.type.is_character(pointer.args[0]) && !pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.type("character", pointer.args[0], atom.indicator)); + return; + } + pointer = pointer.args[1]; + } + } + var list1 = new Term("[]"); + var unilen = stringLength(atom1.id); + for (var i2 = unilen - 1; i2 >= 0; i2--) { + list1 = new Term(".", [new Term(atom1.id.charAt(i2)), list1]); + } + thread.prepend([new State(point.goal.replace(new Term("=", [list, list1])), point.substitution, point)]); + } else { + var pointer = list; + var v = pl.type.is_variable(atom1); + var str = ""; + while (pointer.indicator === "./2") { + if (!pl.type.is_character(pointer.args[0])) { + if (pl.type.is_variable(pointer.args[0]) && v) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.type("character", pointer.args[0], atom.indicator)); + return; + } + } else { + str += pointer.args[0].id; + } + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer) && v) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_empty_list(pointer) && !pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [new Term(str), atom1])), point.substitution, point)]); + } + } + } + }, + "atom_codes/2": function(thread, point, atom) { + var atom1 = atom.args[0], list = atom.args[1]; + if (pl.type.is_variable(atom1) && pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(atom1) && !pl.type.is_atom(atom1)) { + thread.throw_error(pl.error.type("atom", atom1, atom.indicator)); + } else { + if (!pl.type.is_variable(atom1)) { + if (!pl.type.is_variable(list)) { + var pointer = list; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + if (!pl.type.is_character_code(pointer.args[0]) && !pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.type("integer", pointer.args[0], atom.indicator)); + return; + } + pointer = pointer.args[1]; + } + } + var list1 = new Term("[]"); + var unilen = stringLength(atom1.id); + for (var i2 = unilen - 1; i2 >= 0; i2--) { + list1 = new Term(".", [new Num(codePointAt(atom1.id, i2), false), list1]); + } + thread.prepend([new State(point.goal.replace(new Term("=", [list, list1])), point.substitution, point)]); + } else { + var pointer = list; + var v = pl.type.is_variable(atom1); + var str = ""; + while (pointer.indicator === "./2") { + if (!pl.type.is_character_code(pointer.args[0])) { + if (pl.type.is_variable(pointer.args[0]) && v) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.representation("character_code", atom.indicator)); + return; + } + } else { + str += fromCodePoint(pointer.args[0].value); + } + pointer = pointer.args[1]; + } + if (pl.type.is_variable(pointer) && v) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_empty_list(pointer) && !pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [new Term(str), atom1])), point.substitution, point)]); + } + } + } + }, + "char_code/2": function(thread, point, atom) { + var char = atom.args[0], code = atom.args[1]; + if (pl.type.is_variable(char) && pl.type.is_variable(code)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(char) && !pl.type.is_character(char)) { + thread.throw_error(pl.error.type("character", char, atom.indicator)); + } else if (!pl.type.is_variable(code) && !pl.type.is_integer(code)) { + thread.throw_error(pl.error.type("integer", code, atom.indicator)); + } else if (!pl.type.is_variable(code) && !pl.type.is_character_code(code)) { + thread.throw_error(pl.error.representation("character_code", atom.indicator)); + } else { + if (pl.type.is_variable(code)) { + var code1 = new Num(codePointAt(char.id, 0), false); + thread.prepend([new State(point.goal.replace(new Term("=", [code1, code])), point.substitution, point)]); + } else { + var char1 = new Term(fromCodePoint(code.value)); + thread.prepend([new State(point.goal.replace(new Term("=", [char1, char])), point.substitution, point)]); + } + } + }, + "number_chars/2": function(thread, point, atom) { + var str, num = atom.args[0], list = atom.args[1]; + if (pl.type.is_variable(num) && pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(num) && !pl.type.is_number(num)) { + thread.throw_error(pl.error.type("number", num, atom.indicator)); + } else if (!pl.type.is_variable(list) && !pl.type.is_list(list)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + var isvar = pl.type.is_variable(num); + if (!pl.type.is_variable(list)) { + var pointer = list; + var total = true; + str = ""; + while (pointer.indicator === "./2") { + if (!pl.type.is_character(pointer.args[0])) { + if (pl.type.is_variable(pointer.args[0])) { + total = false; + } else if (!pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.type("character", pointer.args[0], atom.indicator)); + return; + } + } else { + str += pointer.args[0].id; + } + pointer = pointer.args[1]; + } + total = total && pl.type.is_empty_list(pointer); + if (!pl.type.is_empty_list(pointer) && !pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + return; + } + if (!total && isvar) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (total) { + if (pl.type.is_variable(pointer) && isvar) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else { + var expr = thread.parse(str); + var num2 = expr.value; + if (!pl.type.is_number(num2) || expr.tokens[expr.tokens.length - 1].space) { + thread.throw_error(pl.error.syntax_by_predicate("parseable_number", atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [num, num2])), point.substitution, point)]); + } + return; + } + } + } + if (!isvar) { + str = num.toString(); + var list2 = new Term("[]"); + for (var i2 = str.length - 1; i2 >= 0; i2--) { + list2 = new Term(".", [new Term(str.charAt(i2)), list2]); + } + thread.prepend([new State(point.goal.replace(new Term("=", [list, list2])), point.substitution, point)]); + } + } + }, + "number_codes/2": function(thread, point, atom) { + var str, num = atom.args[0], list = atom.args[1]; + if (pl.type.is_variable(num) && pl.type.is_variable(list)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(num) && !pl.type.is_number(num)) { + thread.throw_error(pl.error.type("number", num, atom.indicator)); + } else if (!pl.type.is_variable(list) && !pl.type.is_list(list)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + var isvar = pl.type.is_variable(num); + if (!pl.type.is_variable(list)) { + var pointer = list; + var total = true; + str = ""; + while (pointer.indicator === "./2") { + if (!pl.type.is_character_code(pointer.args[0])) { + if (pl.type.is_variable(pointer.args[0])) { + total = false; + } else if (!pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.representation("character_code", atom.indicator)); + return; + } + } else { + str += fromCodePoint(pointer.args[0].value); + } + pointer = pointer.args[1]; + } + total = total && pl.type.is_empty_list(pointer); + if (!pl.type.is_empty_list(pointer) && !pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + return; + } + if (!total && isvar) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (total) { + if (pl.type.is_variable(pointer) && isvar) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else { + var expr = thread.parse(str); + var num2 = expr.value; + if (!pl.type.is_number(num2) || expr.tokens[expr.tokens.length - 1].space) { + thread.throw_error(pl.error.syntax_by_predicate("parseable_number", atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [num, num2])), point.substitution, point)]); + } + return; + } + } + } + if (!isvar) { + str = num.toString(); + var list2 = new Term("[]"); + for (var i2 = str.length - 1; i2 >= 0; i2--) { + list2 = new Term(".", [new Num(codePointAt(str, i2), false), list2]); + } + thread.prepend([new State(point.goal.replace(new Term("=", [list, list2])), point.substitution, point)]); + } + } + }, + "upcase_atom/2": function(thread, point, atom) { + var original = atom.args[0], upcase = atom.args[1]; + if (pl.type.is_variable(original)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(original)) { + thread.throw_error(pl.error.type("atom", original, atom.indicator)); + } else if (!pl.type.is_variable(upcase) && !pl.type.is_atom(upcase)) { + thread.throw_error(pl.error.type("atom", upcase, atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [upcase, new Term(original.id.toUpperCase(), [])])), point.substitution, point)]); + } + }, + "downcase_atom/2": function(thread, point, atom) { + var original = atom.args[0], downcase = atom.args[1]; + if (pl.type.is_variable(original)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(original)) { + thread.throw_error(pl.error.type("atom", original, atom.indicator)); + } else if (!pl.type.is_variable(downcase) && !pl.type.is_atom(downcase)) { + thread.throw_error(pl.error.type("atom", downcase, atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [downcase, new Term(original.id.toLowerCase(), [])])), point.substitution, point)]); + } + }, + "atomic_concat/3": function(thread, point, atom) { + var atomic1 = atom.args[0], atomic2 = atom.args[1], concat = atom.args[2]; + if (pl.type.is_variable(atomic1) || pl.type.is_variable(atomic2)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atomic(atomic1)) { + thread.throw_error(pl.error.type("atomic", atomic1, atom.indicator)); + } else if (!pl.type.is_atomic(atomic2)) { + thread.throw_error(pl.error.type("atomic", atomic2, atom.indicator)); + } else if (!pl.type.is_variable(concat) && !pl.type.is_atom(concat)) { + thread.throw_error(pl.error.type("atom", concat, atom.indicator)); + } else { + var id = ""; + if (pl.type.is_atom(atomic1)) { + id += atomic1.id; + } else { + id += "" + atomic1.value; + } + if (pl.type.is_atom(atomic2)) { + id += atomic2.id; + } else { + id += "" + atomic2.value; + } + var atom = new Term(id, []); + thread.prepend([new State(point.goal.replace(new Term("=", [atom, concat])), point.substitution, point)]); + } + }, + "atomic_list_concat/2": function(thread, point, atom) { + var list = atom.args[0], concat = atom.args[1]; + thread.prepend([new State(point.goal.replace(new Term("atomic_list_concat", [list, new Term("", []), concat])), point.substitution, point)]); + }, + "atomic_list_concat/3": function(thread, point, atom) { + var list = atom.args[0], separator = atom.args[1], concat = atom.args[2]; + if (pl.type.is_variable(separator) || pl.type.is_variable(list) && pl.type.is_variable(concat)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(list) && !pl.type.is_list(list)) { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else if (!pl.type.is_atom(separator) && !pl.type.is_number(separator)) { + thread.throw_error(pl.error.type("atomic", separator, atom.indicator)); + } else if (!pl.type.is_variable(concat) && !pl.type.is_atom(concat)) { + thread.throw_error(pl.error.type("atom", concat, atom.indicator)); + } else { + var id = ""; + var pointer = list; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + if (pl.type.is_variable(pointer.args[0])) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_atom(pointer.args[0]) && !pl.type.is_number(pointer.args[0])) { + thread.throw_error(pl.error.type("atomic", pointer.args[0], atom.indicator)); + return; + } + if (id !== "") + id += separator.id; + if (pl.type.is_atom(pointer.args[0])) + id += pointer.args[0].id; + else + id += "" + pointer.args[0].value; + pointer = pointer.args[1]; + } + id = new Term(id, []); + if (pl.type.is_variable(pointer)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_term(pointer) || pointer.indicator !== "[]/0") { + thread.throw_error(pl.error.type("list", list, atom.indicator)); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [id, concat])), point.substitution, point)]); + } + } + }, + "@=/2": function(thread, point, atom) { + if (pl.compare(atom.args[0], atom.args[1]) > 0) { + thread.success(point); + } + }, + "@>=/2": function(thread, point, atom) { + if (pl.compare(atom.args[0], atom.args[1]) >= 0) { + thread.success(point); + } + }, + "compare/3": function(thread, point, atom) { + var order = atom.args[0], left = atom.args[1], right = atom.args[2]; + if (!pl.type.is_variable(order) && !pl.type.is_atom(order)) { + thread.throw_error(pl.error.type("atom", order, atom.indicator)); + } else if (pl.type.is_atom(order) && ["<", ">", "="].indexOf(order.id) === -1) { + thread.throw_error(pl.error.domain("order", order, atom.indicator)); + } else { + var compare = pl.compare(left, right); + compare = compare === 0 ? "=" : compare === -1 ? "<" : ">"; + thread.prepend([new State(point.goal.replace(new Term("=", [order, new Term(compare, [])])), point.substitution, point)]); + } + }, + "is/2": function(thread, point, atom) { + var op = atom.args[1].interpret(thread); + if (!pl.type.is_number(op)) { + thread.throw_error(op); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [atom.args[0], op], atom.indicator)), point.substitution, point)]); + } + }, + "between/3": function(thread, point, atom) { + var lower = atom.args[0], upper = atom.args[1], bet = atom.args[2]; + if (pl.type.is_variable(lower) || pl.type.is_variable(upper)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(lower)) { + thread.throw_error(pl.error.type("integer", lower, atom.indicator)); + } else if (!pl.type.is_integer(upper)) { + thread.throw_error(pl.error.type("integer", upper, atom.indicator)); + } else if (!pl.type.is_variable(bet) && !pl.type.is_integer(bet)) { + thread.throw_error(pl.error.type("integer", bet, atom.indicator)); + } else { + if (pl.type.is_variable(bet)) { + if (lower.value <= upper.value) { + var states = [new State(point.goal.replace(new Term("=", [bet, lower])), point.substitution, point)]; + states.push(new State(point.goal.replace(new Term("between", [new Num(lower.value + 1, false), upper, bet])), point.substitution, point)); + thread.prepend(states); + } + } else if (lower.value <= bet.value && upper.value >= bet.value) { + thread.success(point); + } + } + }, + "succ/2": function(thread, point, atom) { + var n = atom.args[0], m = atom.args[1]; + if (pl.type.is_variable(n) && pl.type.is_variable(m)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(n) && !pl.type.is_integer(n)) { + thread.throw_error(pl.error.type("integer", n, atom.indicator)); + } else if (!pl.type.is_variable(m) && !pl.type.is_integer(m)) { + thread.throw_error(pl.error.type("integer", m, atom.indicator)); + } else if (!pl.type.is_variable(n) && n.value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", n, atom.indicator)); + } else if (!pl.type.is_variable(m) && m.value < 0) { + thread.throw_error(pl.error.domain("not_less_than_zero", m, atom.indicator)); + } else { + if (pl.type.is_variable(m) || m.value > 0) { + if (pl.type.is_variable(n)) { + thread.prepend([new State(point.goal.replace(new Term("=", [n, new Num(m.value - 1, false)])), point.substitution, point)]); + } else { + thread.prepend([new State(point.goal.replace(new Term("=", [m, new Num(n.value + 1, false)])), point.substitution, point)]); + } + } + } + }, + "=:=/2": function(thread, point, atom) { + var cmp = pl.arithmetic_compare(thread, atom.args[0], atom.args[1]); + if (pl.type.is_term(cmp)) { + thread.throw_error(cmp); + } else if (cmp === 0) { + thread.success(point); + } + }, + "=\\=/2": function(thread, point, atom) { + var cmp = pl.arithmetic_compare(thread, atom.args[0], atom.args[1]); + if (pl.type.is_term(cmp)) { + thread.throw_error(cmp); + } else if (cmp !== 0) { + thread.success(point); + } + }, + "/2": function(thread, point, atom) { + var cmp = pl.arithmetic_compare(thread, atom.args[0], atom.args[1]); + if (pl.type.is_term(cmp)) { + thread.throw_error(cmp); + } else if (cmp > 0) { + thread.success(point); + } + }, + ">=/2": function(thread, point, atom) { + var cmp = pl.arithmetic_compare(thread, atom.args[0], atom.args[1]); + if (pl.type.is_term(cmp)) { + thread.throw_error(cmp); + } else if (cmp >= 0) { + thread.success(point); + } + }, + "var/1": function(thread, point, atom) { + if (pl.type.is_variable(atom.args[0])) { + thread.success(point); + } + }, + "atom/1": function(thread, point, atom) { + if (pl.type.is_atom(atom.args[0])) { + thread.success(point); + } + }, + "atomic/1": function(thread, point, atom) { + if (pl.type.is_atomic(atom.args[0])) { + thread.success(point); + } + }, + "compound/1": function(thread, point, atom) { + if (pl.type.is_compound(atom.args[0])) { + thread.success(point); + } + }, + "integer/1": function(thread, point, atom) { + if (pl.type.is_integer(atom.args[0])) { + thread.success(point); + } + }, + "float/1": function(thread, point, atom) { + if (pl.type.is_float(atom.args[0])) { + thread.success(point); + } + }, + "number/1": function(thread, point, atom) { + if (pl.type.is_number(atom.args[0])) { + thread.success(point); + } + }, + "nonvar/1": function(thread, point, atom) { + if (!pl.type.is_variable(atom.args[0])) { + thread.success(point); + } + }, + "ground/1": function(thread, point, atom) { + if (atom.variables().length === 0) { + thread.success(point); + } + }, + "acyclic_term/1": function(thread, point, atom) { + var test = point.substitution.apply(point.substitution); + var variables = atom.args[0].variables(); + for (var i2 = 0; i2 < variables.length; i2++) + if (point.substitution.links[variables[i2]] !== void 0 && !point.substitution.links[variables[i2]].equals(test.links[variables[i2]])) + return; + thread.success(point); + }, + "callable/1": function(thread, point, atom) { + var callable = atom.args[0]; + if (pl.type.is_term(callable)) { + thread.success(point); + } + }, + "is_list/1": function(thread, point, atom) { + var list = atom.args[0]; + while (pl.type.is_term(list) && list.indicator === "./2") + list = list.args[1]; + if (pl.type.is_term(list) && list.indicator === "[]/0") + thread.success(point); + }, + "current_input/1": function(thread, point, atom) { + var stream = atom.args[0]; + if (!pl.type.is_variable(stream) && (!pl.type.is_stream(stream) || !thread.get_stream_by_alias(stream.alias) && !thread.get_stream_by_alias(stream.id)) && (!pl.type.is_atom(stream) || !thread.get_stream_by_alias(stream.id))) { + thread.throw_error(pl.error.domain("stream", stream, atom.indicator)); + } else { + if (pl.type.is_atom(stream)) + stream = thread.get_stream_by_alias(stream.id); + thread.prepend([ + new State( + point.goal.replace(new Term("=", [stream, thread.get_current_input()])), + point.substitution, + point + ) + ]); + } + }, + "current_output/1": function(thread, point, atom) { + var stream = atom.args[0]; + if (!pl.type.is_variable(stream) && (!pl.type.is_stream(stream) || !thread.get_stream_by_alias(stream.alias) && !thread.get_stream_by_alias(stream.id)) && (!pl.type.is_atom(stream) || !thread.get_stream_by_alias(stream.id))) { + thread.throw_error(pl.error.domain("stream", stream, atom.indicator)); + } else { + if (pl.type.is_atom(stream)) + stream = thread.get_stream_by_alias(stream.id); + thread.prepend([ + new State( + point.goal.replace(new Term("=", [stream, thread.get_current_output()])), + point.substitution, + point + ) + ]); + } + }, + "set_input/1": function(thread, point, atom) { + var input = atom.args[0]; + var stream = pl.type.is_stream(input) ? input : thread.get_stream_by_alias(input.id); + if (pl.type.is_variable(input)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_stream(input) && !pl.type.is_atom(input)) { + thread.throw_error(pl.error.domain("stream_or_alias", input, atom.indicator)); + } else if (!pl.type.is_stream(stream) || !thread.get_stream_by_alias(input.alias) && !thread.get_stream_by_alias(input.id)) { + thread.throw_error(pl.error.existence("stream", input, atom.indicator)); + } else if (stream.output === true) { + thread.throw_error(pl.error.permission("input", "stream", input, atom.indicator)); + } else { + thread.set_current_input(stream); + thread.success(point); + } + }, + "set_output/1": function(thread, point, atom) { + var output = atom.args[0]; + var stream = pl.type.is_stream(output) ? output : thread.get_stream_by_alias(output.id); + if (pl.type.is_variable(output)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_stream(output) && !pl.type.is_atom(output)) { + thread.throw_error(pl.error.domain("stream_or_alias", output, atom.indicator)); + } else if (!pl.type.is_stream(stream) || !thread.get_stream_by_alias(output.alias) && !thread.get_stream_by_alias(output.id)) { + thread.throw_error(pl.error.existence("stream", output, atom.indicator)); + } else if (stream.input === true) { + thread.throw_error(pl.error.permission("output", "stream", output, atom.indicator)); + } else { + thread.set_current_output(stream); + thread.success(point); + } + }, + "open/3": function(thread, point, atom) { + var dest = atom.args[0], mode = atom.args[1], stream = atom.args[2]; + thread.prepend([new State( + point.goal.replace(new Term("open", [dest, mode, stream, new Term("[]", [])])), + point.substitution, + point + )]); + }, + "open/4": function(thread, point, atom) { + var dest = atom.args[0], mode = atom.args[1], stream = atom.args[2], options = atom.args[3]; + if (pl.type.is_variable(dest) || pl.type.is_variable(mode) || pl.type.is_variable(options)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(mode) && !pl.type.is_atom(mode)) { + thread.throw_error(pl.error.type("atom", mode, atom.indicator)); + } else if (!pl.type.is_list(options)) { + thread.throw_error(pl.error.type("list", options, atom.indicator)); + } else if (!pl.type.is_variable(stream)) { + thread.throw_error(pl.error.uninstantiation(stream, atom.indicator)); + } else if (!pl.type.is_atom(dest) && !pl.type.is_streamable(dest)) { + thread.throw_error(pl.error.domain("source_sink", dest, atom.indicator)); + } else if (!pl.type.is_io_mode(mode)) { + thread.throw_error(pl.error.domain("io_mode", mode, atom.indicator)); + } else { + var obj_options = {}; + var pointer = options; + var property; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + property = pointer.args[0]; + if (pl.type.is_variable(property)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_stream_option(property)) { + thread.throw_error(pl.error.domain("stream_option", property, atom.indicator)); + return; + } + obj_options[property.id] = property.args[0].id; + pointer = pointer.args[1]; + } + if (pointer.indicator !== "[]/0") { + if (pl.type.is_variable(pointer)) + thread.throw_error(pl.error.instantiation(atom.indicator)); + else + thread.throw_error(pl.error.type("list", options, atom.indicator)); + return; + } else { + var alias = obj_options["alias"]; + if (alias && thread.get_stream_by_alias(alias)) { + thread.throw_error(pl.error.permission("open", "source_sink", new Term("alias", [new Term(alias, [])]), atom.indicator)); + return; + } + if (!obj_options["type"]) + obj_options["type"] = "text"; + var file; + if (pl.type.is_atom(dest)) + file = thread.file_system_open(dest.id, obj_options["type"], mode.id); + else + file = dest.stream(obj_options["type"], mode.id); + if (file === false) { + thread.throw_error(pl.error.permission("open", "source_sink", dest, atom.indicator)); + return; + } else if (file === null) { + thread.throw_error(pl.error.existence("source_sink", dest, atom.indicator)); + return; + } + var newstream = new Stream( + file, + mode.id, + obj_options["alias"], + obj_options["type"], + obj_options["reposition"] === "true", + obj_options["eof_action"] + ); + if (alias) + thread.session.streams[alias] = newstream; + else + thread.session.streams[newstream.id] = newstream; + thread.prepend([new State( + point.goal.replace(new Term("=", [stream, newstream])), + point.substitution, + point + )]); + } + } + }, + "close/1": function(thread, point, atom) { + var stream = atom.args[0]; + thread.prepend([new State( + point.goal.replace(new Term("close", [stream, new Term("[]", [])])), + point.substitution, + point + )]); + }, + "close/2": function(thread, point, atom) { + var stream = atom.args[0], options = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(options)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_list(options)) { + thread.throw_error(pl.error.type("list", options, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else { + var obj_options = {}; + var pointer = options; + var property; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + property = pointer.args[0]; + if (pl.type.is_variable(property)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_close_option(property)) { + thread.throw_error(pl.error.domain("close_option", property, atom.indicator)); + return; + } + obj_options[property.id] = property.args[0].id === "true"; + pointer = pointer.args[1]; + } + if (pointer.indicator !== "[]/0") { + if (pl.type.is_variable(pointer)) + thread.throw_error(pl.error.instantiation(atom.indicator)); + else + thread.throw_error(pl.error.type("list", options, atom.indicator)); + return; + } else { + if (stream2 === thread.session.standard_input || stream2 === thread.session.standard_output || stream2 === thread.session.standard_error) { + thread.success(point); + return; + } else if (stream2 === thread.session.current_input) { + thread.session.current_input = thread.session.standard_input; + } else if (stream2 === thread.session.current_output) { + thread.session.current_output = thread.session.standard_output; + } + if (stream2.alias !== null && stream2.alias !== void 0) + delete thread.session.streams[stream2.alias]; + else + delete thread.session.streams[stream2.id]; + if (stream2.output) + stream2.stream.flush(); + var closed = stream2.stream.close(); + stream2.stream = null; + if (obj_options.force === true || closed === true) { + thread.success(point); + } + } + } + }, + "flush_output/0": [ + new Rule(new Term("flush_output", []), new Term(",", [new Term("current_output", [new Var("S")]), new Term("flush_output", [new Var("S")])])) + ], + "flush_output/1": function(thread, point, atom) { + var stream = atom.args[0]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.input === true) { + thread.throw_error(pl.error.permission("output", "stream", stream, atom.indicator)); + } else { + stream2.stream.flush(); + thread.success(point); + } + }, + "stream_property/2": function(thread, point, atom) { + var stream = atom.args[0], property = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (!pl.type.is_variable(stream) && !pl.type.is_stream(stream)) { + thread.throw_error(pl.error.domain("stream", stream, atom.indicator)); + } else if (!pl.type.is_variable(stream) && (!pl.type.is_stream(stream2) || stream2.stream === null)) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (!pl.type.is_variable(property) && !pl.type.is_stream_property(property)) { + thread.throw_error(pl.error.domain("stream_property", property, atom.indicator)); + } else { + var streams = []; + var states = []; + var propvar = pl.type.is_variable(property); + if (!pl.type.is_variable(stream)) + streams.push(stream2); + else + for (var key in thread.session.streams) + streams.push(thread.session.streams[key]); + for (var i2 = 0; i2 < streams.length; i2++) { + var properties = []; + if ((propvar || property.indicator === "file_name/1") && streams[i2].filename) + properties.push(new Term("file_name", [new Term(streams[i2].file_name, [])])); + if (propvar || property.indicator === "mode/1") + properties.push(new Term("mode", [new Term(streams[i2].mode, [])])); + if (propvar || property.indicator === "input/0" || property.indicator === "output/0") + properties.push(new Term(streams[i2].input ? "input" : "output", [])); + if ((propvar || property.indicator === "alias/1") && streams[i2].alias) + properties.push(new Term("alias", [new Term(streams[i2].alias, [])])); + if (propvar || property.indicator === "position/1") + properties.push(new Term("position", [ + new Term("position", [ + new Num(streams[i2].char_count, false), + new Num(streams[i2].line_count, false), + new Num(streams[i2].line_position, false) + ]) + ])); + if (propvar || property.indicator === "end_of_stream/1") + properties.push(new Term("end_of_stream", [new Term( + streams[i2].position === "end_of_stream" || streams[i2].stream.eof && streams[i2].stream.eof(streams[i2].position) ? "at" : streams[i2].position === "past_end_of_stream" ? "past" : "not", + [] + )])); + if (propvar || property.indicator === "eof_action/1") + properties.push(new Term("eof_action", [new Term(streams[i2].eof_action, [])])); + if (propvar || property.indicator === "reposition/1") + properties.push(new Term("reposition", [new Term(streams[i2].reposition ? "true" : "false", [])])); + if (propvar || property.indicator === "type/1") + properties.push(new Term("type", [new Term(streams[i2].type, [])])); + for (var j = 0; j < properties.length; j++) { + states.push(new State( + point.goal.replace(new Term(",", [ + new Term("=", [pl.type.is_variable(stream) ? stream : stream2, streams[i2]]), + new Term("=", [property, properties[j]]) + ])), + point.substitution, + point + )); + } + } + thread.prepend(states); + } + }, + "stream_position_data/3": function(thread, point, atom) { + var field = atom.args[0], position = atom.args[1], value = atom.args[2]; + if (pl.type.is_variable(position)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_term(position) || position.indicator !== "position/3") { + thread.throw_error(pl.error.domain("stream_position", position, atom.indicator)); + } else if (!pl.type.is_variable(field) && !pl.type.is_atom(field)) { + thread.throw_error(pl.error.type("atom", field, atom.indicator)); + } else if (!pl.type.is_variable(value) && !pl.type.is_integer(value)) { + thread.throw_error(pl.error.type("integer", value, atom.indicator)); + } else { + var fields = ["char_count", "line_count", "line_position"]; + var states = []; + var data_pos = { char_count: 0, line_count: 1, line_position: 2 }; + if (pl.type.is_variable(field)) { + for (var i2 = 0; i2 < fields.length; i2++) { + states.push(new State(point.goal.replace( + new Term(",", [ + new Term("=", [new Term(fields[i2]), field]), + new Term("=", [value, position.args[data_pos[fields[i2]]]]) + ]) + ), point.substitution, point)); + } + } else if (data_pos.hasOwnProperty(field.id)) { + states.push(new State(point.goal.replace( + new Term("=", [value, position.args[data_pos[field.id]]]) + ), point.substitution, point)); + } + thread.prepend(states); + } + }, + "at_end_of_stream/0": [ + new Rule(new Term("at_end_of_stream", []), new pl.type.Term(",", [new Term("current_input", [new Var("S")]), new Term(",", [new Term("stream_property", [new Var("S"), new Term("end_of_stream", [new Var("E")])]), new Term(",", [new Term("!", []), new Term(";", [new Term("=", [new Var("E"), new Term("at", [])]), new Term("=", [new Var("E"), new Term("past", [])])])])])])) + ], + "at_end_of_stream/1": function(thread, point, atom) { + var stream = atom.args[0]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else { + var e = thread.next_free_variable(); + thread.prepend([new State( + point.goal.replace( + new Term(",", [ + new Term("stream_property", [stream2, new Term("end_of_stream", [e])]), + new Term(",", [new Term("!", []), new Term(";", [ + new Term("=", [e, new Term("at", [])]), + new Term("=", [e, new Term("past", [])]) + ])]) + ]) + ), + point.substitution, + point + )]); + } + }, + "set_stream_position/2": function(thread, point, atom) { + var stream = atom.args[0], position = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(position)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (!pl.type.is_stream_position(position)) { + thread.throw_error(pl.error.domain("stream_position", position, atom.indicator)); + } else if (stream2.reposition === false) { + thread.throw_error(pl.error.permission("reposition", "stream", stream, atom.indicator)); + } else { + if (position.indicator === "position/3") { + stream2.position = position.args[0].value; + stream2.char_count = position.args[0].value; + stream2.line_count = position.args[1].value; + stream2.line_position = position.args[2].value; + } else { + stream2.position = position.id; + } + thread.success(point); + } + }, + "get_char/1": [ + new Rule(new Term("get_char", [new Var("C")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("get_char", [new Var("S"), new Var("C")])])) + ], + "get_char/2": function(thread, point, atom) { + var stream = atom.args[0], char = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(char) && !pl.type.is_in_character(char)) { + thread.throw_error(pl.error.type("in_character", char, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("input", "binary_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else { + var stream_char; + if (stream2.position === "end_of_stream") { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else if (stream2.position === "past_end_of_stream") { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream_char = stream2.stream.get(1, stream2.position); + if (stream_char === null) { + thread.throw_error(pl.error.representation("character", atom.indicator)); + return; + } else if (stream_char === "end_of_stream") { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream2.position++; + stream2.char_count++; + stream2.line_position++; + if (stream_char === "\n") { + stream2.line_count++; + stream2.line_position = 0; + } + } + } + thread.prepend([new State( + point.goal.replace(new Term("=", [new Term(stream_char, []), char])), + point.substitution, + point + )]); + } + }, + "get_code/1": [ + new Rule(new Term("get_code", [new Var("C")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("get_code", [new Var("S"), new Var("C")])])) + ], + "get_code/2": function(thread, point, atom) { + var stream = atom.args[0], code = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(code) && !pl.type.is_integer(code)) { + thread.throw_error(pl.error.type("integer", code, atom.indicator)); + } else if (pl.type.is_integer(code) && !pl.type.is_in_character_code(code)) { + thread.throw_error(pl.error.representation("in_character_code", atom.indicator)); + } else if (!pl.type.is_variable(stream) && !pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("input", "binary_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else { + var stream_code; + if (stream2.position === "end_of_stream") { + stream_code = -1; + stream2.position = "past_end_of_stream"; + } else if (stream2.position === "past_end_of_stream") { + stream_code = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_code = stream2.stream.get(1, stream2.position); + if (stream_code === null) { + thread.throw_error(pl.error.representation("character", atom.indicator)); + return; + } else if (stream_code === "end_of_stream") { + stream_code = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_code = codePointAt(stream_code, 0); + stream2.position++; + stream2.char_count++; + stream2.line_position++; + if (stream_code === 10) { + stream2.line_count++; + stream2.line_position = 0; + } + } + } + thread.prepend([new State( + point.goal.replace(new Term("=", [new Num(stream_code, false), code])), + point.substitution, + point + )]); + } + }, + "peek_char/1": [ + new Rule(new Term("peek_char", [new Var("C")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("peek_char", [new Var("S"), new Var("C")])])) + ], + "peek_char/2": function(thread, point, atom) { + var stream = atom.args[0], char = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(char) && !pl.type.is_in_character(char)) { + thread.throw_error(pl.error.type("in_character", char, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("input", "binary_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else { + var stream_char; + if (stream2.position === "end_of_stream") { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else if (stream2.position === "past_end_of_stream") { + stream_char = "end_of_file"; + stream2.position = "past_end_of_stream"; + } else { + stream_char = stream2.stream.get(1, stream2.position); + if (stream_char === null) { + thread.throw_error(pl.error.representation("character", atom.indicator)); + return; + } else if (stream_char === "end_of_stream") { + stream_char = "end_of_file"; + } + } + thread.prepend([new State( + point.goal.replace(new Term("=", [new Term(stream_char, []), char])), + point.substitution, + point + )]); + } + }, + "peek_code/1": [ + new Rule(new Term("peek_code", [new Var("C")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("peek_code", [new Var("S"), new Var("C")])])) + ], + "peek_code/2": function(thread, point, atom) { + var stream = atom.args[0], code = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(code) && !pl.type.is_integer(code)) { + thread.throw_error(pl.error.type("integer", code, atom.indicator)); + } else if (pl.type.is_integer(code) && !pl.type.is_in_character_code(code)) { + thread.throw_error(pl.error.representation("in_character_code", atom.indicator)); + } else if (!pl.type.is_variable(stream) && !pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("input", "binary_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else { + var stream_code; + if (stream2.position === "end_of_stream") { + stream_code = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_code = stream2.stream.get(1, stream2.position); + if (stream_code === null) { + thread.throw_error(pl.error.representation("character", atom.indicator)); + return; + } else if (stream_code === "end_of_stream") { + stream_code = -1; + } else { + stream_code = codePointAt(stream_code, 0); + } + } + thread.prepend([new State( + point.goal.replace(new Term("=", [new Num(stream_code, false), code])), + point.substitution, + point + )]); + } + }, + "put_char/1": [ + new Rule(new Term("put_char", [new Var("C")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("put_char", [new Var("S"), new Var("C")])])) + ], + "put_char/2": function(thread, point, atom) { + var stream = atom.args[0], char = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(char)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_character(char)) { + thread.throw_error(pl.error.type("character", char, atom.indicator)); + } else if (!pl.type.is_variable(stream) && !pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.input) { + thread.throw_error(pl.error.permission("output", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("output", "binary_stream", stream, atom.indicator)); + } else { + if (stream2.stream.put(char.id, stream2.position)) { + if (typeof stream2.position === "number") + stream2.position++; + stream2.char_count++; + stream2.line_position++; + if (char.id === "\n") { + stream2.line_count++; + stream2.line_position = 0; + } + thread.success(point); + } + } + }, + "put_code/1": [ + new Rule(new Term("put_code", [new Var("C")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("put_code", [new Var("S"), new Var("C")])])) + ], + "put_code/2": function(thread, point, atom) { + var stream = atom.args[0], code = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(code)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(code)) { + thread.throw_error(pl.error.type("integer", code, atom.indicator)); + } else if (!pl.type.is_character_code(code)) { + thread.throw_error(pl.error.representation("character_code", atom.indicator)); + } else if (!pl.type.is_variable(stream) && !pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.input) { + thread.throw_error(pl.error.permission("output", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("output", "binary_stream", stream, atom.indicator)); + } else { + if (stream2.stream.put(fromCodePoint(code.value), stream2.position)) { + if (typeof stream2.position === "number") + stream2.position++; + stream2.char_count++; + stream2.line_position++; + if (code.value === 10) { + stream2.line_count++; + stream2.line_position = 0; + } + thread.success(point); + } + } + }, + "nl/0": [ + new Rule(new Term("nl"), new Term(",", [new Term("current_output", [new Var("S")]), new Term("put_char", [new Var("S"), new Term("\n")])])) + ], + "nl/1": function(thread, point, atom) { + var stream = atom.args[0]; + thread.prepend([new State( + point.goal.replace(new Term("put_char", [stream, new Term("\n", [])])), + point.substitution, + point + )]); + }, + "get_byte/1": [ + new Rule(new Term("get_byte", [new Var("B")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("get_byte", [new Var("S"), new Var("B")])])) + ], + "get_byte/2": function(thread, point, atom) { + var stream = atom.args[0], byte = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(byte) && !pl.type.is_in_byte(byte)) { + thread.throw_error(pl.error.type("in_byte", byte, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "text") { + thread.throw_error(pl.error.permission("input", "text_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else { + var stream_byte; + if (stream2.position === "end_of_stream") { + stream_byte = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_byte = stream2.stream.get_byte(stream2.position); + if (stream_byte === null) { + thread.throw_error(pl.error.representation("byte", atom.indicator)); + return; + } else if (stream_byte === "end_of_stream") { + stream_byte = -1; + stream2.position = "past_end_of_stream"; + } else { + stream2.position++; + stream2.char_count++; + stream2.line_position++; + } + } + thread.prepend([new State( + point.goal.replace(new Term("=", [new Num(stream_byte, false), byte])), + point.substitution, + point + )]); + } + }, + "peek_byte/1": [ + new Rule(new Term("peek_byte", [new Var("B")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("peek_byte", [new Var("S"), new Var("B")])])) + ], + "peek_byte/2": function(thread, point, atom) { + var stream = atom.args[0], byte = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(byte) && !pl.type.is_in_byte(byte)) { + thread.throw_error(pl.error.type("in_byte", byte, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "text") { + thread.throw_error(pl.error.permission("input", "text_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else { + var stream_byte; + if (stream2.position === "end_of_stream") { + stream_byte = -1; + stream2.position = "past_end_of_stream"; + } else { + stream_byte = stream2.stream.get_byte(stream2.position); + if (stream_byte === null) { + thread.throw_error(pl.error.representation("byte", atom.indicator)); + return; + } else if (stream_byte === "end_of_stream") { + stream_byte = -1; + } + } + thread.prepend([new State( + point.goal.replace(new Term("=", [new Num(stream_byte, false), byte])), + point.substitution, + point + )]); + } + }, + "put_byte/1": [ + new Rule(new Term("put_byte", [new Var("B")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("put_byte", [new Var("S"), new Var("B")])])) + ], + "put_byte/2": function(thread, point, atom) { + var stream = atom.args[0], byte = atom.args[1]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(byte)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_byte(byte)) { + thread.throw_error(pl.error.type("byte", byte, atom.indicator)); + } else if (!pl.type.is_variable(stream) && !pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.input) { + thread.throw_error(pl.error.permission("output", "stream", stream, atom.indicator)); + } else if (stream2.type === "text") { + thread.throw_error(pl.error.permission("output", "text_stream", stream, atom.indicator)); + } else { + if (stream2.stream.put_byte(byte.value, stream2.position)) { + if (typeof stream2.position === "number") + stream2.position++; + stream2.char_count++; + stream2.line_position++; + thread.success(point); + } + } + }, + "read/1": [ + new Rule(new Term("read", [new Var("T")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("read_term", [new Var("S"), new Var("T"), new Term("[]")])])) + ], + "read/2": [ + new Rule(new Term("read", [new Var("S"), new Var("T")]), new Term("read_term", [new Var("S"), new Var("T"), new Term("[]")])) + ], + "read_term/2": [ + new Rule(new Term("read_term", [new Var("T"), new Var("O")]), new Term(",", [new Term("current_input", [new Var("S")]), new Term("read_term", [new Var("S"), new Var("T"), new Var("O")])])) + ], + "read_term/3": function(thread, point, atom) { + var stream = atom.args[0], term = atom.args[1], options = atom.args[2]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(options)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_list(options)) { + thread.throw_error(pl.error.type("list", options, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.output) { + thread.throw_error(pl.error.permission("input", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("input", "binary_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("input", "past_end_of_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "eof_code") { + expr = { + value: new Term("end_of_file", []), + type: SUCCESS, + len: -1 + }; + } else { + var obj_options = {}; + var pointer = options; + var property; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + property = pointer.args[0]; + if (pl.type.is_variable(property)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_read_option(property)) { + thread.throw_error(pl.error.domain("read_option", property, atom.indicator)); + return; + } + obj_options[property.id] = property.args[0]; + pointer = pointer.args[1]; + } + if (pointer.indicator !== "[]/0") { + if (pl.type.is_variable(pointer)) + thread.throw_error(pl.error.instantiation(atom.indicator)); + else + thread.throw_error(pl.error.type("list", options, atom.indicator)); + return; + } else { + var char, tokenizer, expr; + var text = ""; + var tokens = []; + var last_token = null; + var lexical_error = false; + while (last_token === null || lexical_error || last_token.name !== "atom" || last_token.value !== "." || tokens.length > 0 && expr.type === ERROR) { + char = stream2.stream.get(1, stream2.position); + while (char !== null && char !== "." && char !== "end_of_stream" && char !== "past_end_of_stream") { + stream2.position++; + text += char; + char = stream2.stream.get(1, stream2.position); + } + if (char === null) { + thread.throw_error(pl.error.representation("character", atom.indicator)); + return; + } else if (char === "end_of_stream" || char === "past_end_of_stream") { + if (tokens === null || tokens.length === 0) { + stream2.position = "past_end_of_stream"; + expr = { + value: new Term("end_of_file", []), + type: SUCCESS, + len: -1 + }; + break; + } else if (expr) { + thread.throw_error(pl.error.syntax(last_token, "unexpected end of file", false)); + return; + } else { + thread.throw_error(pl.error.syntax(last_token, "token not found", true)); + return; + } + } else if (char === ".") { + stream2.position++; + text += char; + } + tokenizer = new Tokenizer(thread); + tokenizer.new_text(text); + tokens = tokenizer.get_tokens(); + num_token = tokens !== null && tokens.length > 1 ? tokens[tokens.length - 2] : null; + last_token = tokens !== null && tokens.length > 0 ? tokens[tokens.length - 1] : null; + if (tokens === null) + continue; + lexical_error = false; + for (var i2 = 0; i2 < tokens.length && !lexical_error; i2++) + lexical_error = tokens[i2].name === "lexical"; + if (lexical_error) + continue; + expr = parseExpr(thread, tokens, 0, thread.__get_max_priority(), false); + if (num_token && num_token.name === "number" && !num_token.float && !num_token.blank && last_token.value === ".") { + var next_char = stream2.stream.get(1, stream2.position); + if (next_char >= "0" && next_char <= "9") { + stream2.position++; + text += next_char; + last_token = null; + continue; + } + } + } + if (last_token) { + if (last_token.line_position === last_token.len) + stream2.line_position += last_token.line_position; + else + stream2.line_position = last_token.line_position; + stream2.line_count += last_token.line_count; + stream2.char_count += last_token.len; + } + if (expr.type === SUCCESS && (expr.len === -1 || expr.len === tokens.length - 1 && last_token.value === ".")) { + thread.session.renamed_variables = {}; + expr = expr.value.rename(thread); + var eq = new Term("=", [term, expr]); + if (obj_options.variables) { + var vars = arrayToList(map(nub(expr.variables()), function(v2) { + return new Var(v2); + })); + eq = new Term(",", [eq, new Term("=", [obj_options.variables, vars])]); + } + if (obj_options.variable_names) { + var vars = nub(expr.variables()); + var plvars = []; + for (var i2 = 0; i2 < vars.length; i2++) { + var v = vars[i2]; + for (var prop in thread.session.renamed_variables) { + if (thread.session.renamed_variables.hasOwnProperty(prop)) { + if (thread.session.renamed_variables[prop] === v) { + plvars.push(new Term("=", [new Term(prop, []), new Var(v)])); + break; + } + } + } + } + plvars = arrayToList(plvars); + eq = new Term(",", [eq, new Term("=", [obj_options.variable_names, plvars])]); + } + if (obj_options.singletons) { + var vars = nub(new Rule(expr, null).singleton_variables(true)); + var plvars = []; + for (var i2 = 0; i2 < vars.length; i2++) { + var v = vars[i2]; + for (var prop in thread.session.renamed_variables) { + if (thread.session.renamed_variables.hasOwnProperty(prop)) { + if (thread.session.renamed_variables[prop] === v) { + plvars.push(new Term("=", [new Term(prop, []), new Var(v)])); + break; + } + } + } + } + plvars = arrayToList(plvars); + eq = new Term(",", [eq, new Term("=", [obj_options.singletons, plvars])]); + } + thread.prepend([new State(point.goal.replace(eq), point.substitution, point)]); + } else { + if (expr.type === SUCCESS) + thread.throw_error(pl.error.syntax(tokens[expr.len], "unexpected token", false)); + else + thread.throw_error(expr.value); + } + } + } + }, + "write/1": [ + new Rule(new Term("write", [new Var("T")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("write", [new Var("S"), new Var("T")])])) + ], + "write/2": function(thread, point, atom) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend([new State( + point.goal.replace(new Term("write_term", [ + stream, + term, + new Term(".", [ + new Term("quoted", [new Term("false", [])]), + new Term(".", [ + new Term("ignore_ops", [new Term("false")]), + new Term(".", [new Term("numbervars", [new Term("true")]), new Term("[]", [])]) + ]) + ]) + ])), + point.substitution, + point + )]); + }, + "writeq/1": [ + new Rule(new Term("writeq", [new Var("T")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("writeq", [new Var("S"), new Var("T")])])) + ], + "writeq/2": function(thread, point, atom) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend([new State( + point.goal.replace(new Term("write_term", [ + stream, + term, + new Term(".", [ + new Term("quoted", [new Term("true", [])]), + new Term(".", [ + new Term("ignore_ops", [new Term("false")]), + new Term(".", [new Term("numbervars", [new Term("true")]), new Term("[]", [])]) + ]) + ]) + ])), + point.substitution, + point + )]); + }, + "write_canonical/1": [ + new Rule(new Term("write_canonical", [new Var("T")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("write_canonical", [new Var("S"), new Var("T")])])) + ], + "write_canonical/2": function(thread, point, atom) { + var stream = atom.args[0], term = atom.args[1]; + thread.prepend([new State( + point.goal.replace(new Term("write_term", [ + stream, + term, + new Term(".", [ + new Term("quoted", [new Term("true", [])]), + new Term(".", [ + new Term("ignore_ops", [new Term("true")]), + new Term(".", [new Term("numbervars", [new Term("false")]), new Term("[]", [])]) + ]) + ]) + ])), + point.substitution, + point + )]); + }, + "write_term/2": [ + new Rule(new Term("write_term", [new Var("T"), new Var("O")]), new Term(",", [new Term("current_output", [new Var("S")]), new Term("write_term", [new Var("S"), new Var("T"), new Var("O")])])) + ], + "write_term/3": function(thread, point, atom) { + var stream = atom.args[0], term = atom.args[1], options = atom.args[2]; + var stream2 = pl.type.is_stream(stream) ? stream : thread.get_stream_by_alias(stream.id); + if (pl.type.is_variable(stream) || pl.type.is_variable(options)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_list(options)) { + thread.throw_error(pl.error.type("list", options, atom.indicator)); + } else if (!pl.type.is_stream(stream) && !pl.type.is_atom(stream)) { + thread.throw_error(pl.error.domain("stream_or_alias", stream, atom.indicator)); + } else if (!pl.type.is_stream(stream2) || stream2.stream === null) { + thread.throw_error(pl.error.existence("stream", stream, atom.indicator)); + } else if (stream2.input) { + thread.throw_error(pl.error.permission("output", "stream", stream, atom.indicator)); + } else if (stream2.type === "binary") { + thread.throw_error(pl.error.permission("output", "binary_stream", stream, atom.indicator)); + } else if (stream2.position === "past_end_of_stream" && stream2.eof_action === "error") { + thread.throw_error(pl.error.permission("output", "past_end_of_stream", stream, atom.indicator)); + } else { + var obj_options = {}; + var pointer = options; + var property; + while (pl.type.is_term(pointer) && pointer.indicator === "./2") { + property = pointer.args[0]; + if (pl.type.is_variable(property)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + return; + } else if (!pl.type.is_write_option(property)) { + thread.throw_error(pl.error.domain("write_option", property, atom.indicator)); + return; + } + if (property.indicator === "variable_names/1") + obj_options[property.id] = property.args[0]; + else + obj_options[property.id] = property.args[0].id === "true"; + pointer = pointer.args[1]; + } + if (pointer.indicator !== "[]/0") { + if (pl.type.is_variable(pointer)) + thread.throw_error(pl.error.instantiation(atom.indicator)); + else + thread.throw_error(pl.error.type("list", options, atom.indicator)); + return; + } else { + obj_options.session = thread.session; + var text = term.toString(obj_options); + stream2.stream.put(text, stream2.position); + if (typeof stream2.position === "number") + stream2.position += text.length; + var nl = (text.match(/\n/g) || []).length; + stream2.line_count += nl; + if (nl > 0) + stream2.line_position = text.length - text.lastIndexOf("\n") - 1; + else + stream2.line_position += text.length; + stream2.char_count += text.length; + thread.success(point); + } + } + }, + "halt/0": function(thread, point, _) { + if (thread.get_flag("nodejs").indicator === "true/0") + process.exit(); + thread.points = []; + }, + "halt/1": function(thread, point, atom) { + var int = atom.args[0]; + if (pl.type.is_variable(int)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_integer(int)) { + thread.throw_error(pl.error.type("integer", int, atom.indicator)); + } else { + if (thread.get_flag("nodejs").indicator === "true/0") + process.exit(int.value); + thread.points = []; + } + }, + "current_prolog_flag/2": function(thread, point, atom) { + var flag = atom.args[0], value = atom.args[1]; + if (!pl.type.is_variable(flag) && !pl.type.is_atom(flag)) { + thread.throw_error(pl.error.type("atom", flag, atom.indicator)); + } else if (!pl.type.is_variable(flag) && !pl.type.is_flag(flag)) { + thread.throw_error(pl.error.domain("prolog_flag", flag, atom.indicator)); + } else { + var states = []; + for (var name in pl.flag) { + if (!pl.flag.hasOwnProperty(name)) + continue; + var goal = new Term(",", [new Term("=", [new Term(name), flag]), new Term("=", [thread.get_flag(name), value])]); + states.push(new State(point.goal.replace(goal), point.substitution, point)); + } + thread.prepend(states); + } + }, + "set_prolog_flag/2": function(thread, point, atom) { + var flag = atom.args[0], value = atom.args[1]; + if (pl.type.is_variable(flag) || pl.type.is_variable(value)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(flag)) { + thread.throw_error(pl.error.type("atom", flag, atom.indicator)); + } else if (!pl.type.is_flag(flag)) { + thread.throw_error(pl.error.domain("prolog_flag", flag, atom.indicator)); + } else if (!pl.type.is_modifiable_flag(flag)) { + thread.throw_error(pl.error.permission("modify", "flag", flag, atom.indicator)); + } else if (!pl.type.is_value_flag(flag, value)) { + thread.throw_error(pl.error.domain("flag_value", new Term("+", [flag, value]), atom.indicator)); + } else { + thread.session.flag[flag.id] = value; + thread.success(point); + } + }, + "consult/1": function(thread, point, atom) { + var src = atom.args[0]; + var context_module = "user"; + if (src.indicator === ":/2") { + context_module = src.args[0].id; + src = src.args[1]; + } + if (pl.type.is_variable(src)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_atom(src)) { + thread.throw_error(pl.error.type("atom", src, atom.indicator)); + } else { + if (thread.consult(src.id, { + context_module, + text: false, + html: false, + success: function() { + thread.success(point); + thread.again(); + }, + error: function(err) { + thread.throw_error(err); + thread.again(); + } + })) + ; + return true; + } + }, + "get_time/1": function(thread, point, atom) { + var time = atom.args[0]; + if (!pl.type.is_variable(time) && !pl.type.is_number(time)) { + thread.throw_error(pl.error.type("number", time, atom.indicator)); + } else { + var current = new Num(Date.now(), true); + thread.prepend([new State( + point.goal.replace(new Term("=", [time, current])), + point.substitution, + point + )]); + } + }, + "time_property/2": function(thread, point, atom) { + var time = atom.args[0], property = atom.args[1]; + if (pl.type.is_variable(time)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_variable(time) && !pl.type.is_number(time)) { + thread.throw_error(pl.error.type("number", time, atom.indicator)); + } else if (!pl.type.is_variable(property) && !pl.type.is_time_property(property)) { + thread.throw_error(pl.error.domain("time_property", property, atom.indicator)); + } else { + var props; + if (pl.type.is_variable(property)) { + props = ["year", "month", "day", "hours", "minutes", "seconds", "milliseconds", "weekday"]; + } else { + props = [property.id]; + } + var date = new Date(time.value); + var value; + var states = []; + for (var i2 = 0; i2 < props.length; i2++) { + switch (props[i2]) { + case "year": + value = new Term("year", [new Num(date.getFullYear(), false)]); + break; + case "month": + value = new Term("month", [new Num(date.getMonth(), false)]); + break; + case "day": + value = new Term("day", [new Num(date.getDate(), false)]); + break; + case "hours": + value = new Term("hours", [new Num(date.getHours(), false)]); + break; + case "minutes": + value = new Term("minutes", [new Num(date.getMinutes(), false)]); + break; + case "seconds": + value = new Term("seconds", [new Num(date.getSeconds(), false)]); + break; + case "milliseconds": + value = new Term("milliseconds", [new Num(date.getMilliseconds(), false)]); + break; + case "weekday": + value = new Term("weekday", [new Num(date.getDay(), false)]); + break; + } + states.push(new State( + point.goal.replace(new Term("=", [property, value])), + point.substitution, + point + )); + } + thread.prepend(states); + } + }, + "time_year/2": function(thread, point, atom) { + var time = atom.args[0], year = atom.args[1]; + if (pl.type.is_variable(time)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_number(time)) { + thread.throw_error(pl.error.type("number", time, atom.indicator)); + } else if (!pl.type.is_variable(year) && !pl.type.is_integer(year)) { + thread.throw_error(pl.error.type("integer", year, atom.indicator)); + } else { + var value = new Num(new Date(time.value).getFullYear(), false); + thread.prepend([new State( + point.goal.replace(new Term("=", [year, value])), + point.substitution, + point + )]); + } + }, + "time_month/2": function(thread, point, atom) { + var time = atom.args[0], month = atom.args[1]; + if (pl.type.is_variable(time)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_number(time)) { + thread.throw_error(pl.error.type("number", time, atom.indicator)); + } else if (!pl.type.is_variable(month) && !pl.type.is_integer(month)) { + thread.throw_error(pl.error.type("integer", month, atom.indicator)); + } else { + var value = new Num(new Date(time.value).getMonth(), false); + thread.prepend([new State( + point.goal.replace(new Term("=", [month, value])), + point.substitution, + point + )]); + } + }, + "phrase/3": function(thread, point, atom) { + var grbody = atom.args[0], s0 = atom.args[1], s = atom.args[2]; + var context_module = "user"; + if (grbody.indicator === ":/2") { + context_module = grbody.args[0].id; + grbody = grbody.args[1]; + } + if (pl.type.is_variable(grbody)) { + thread.throw_error(pl.error.instantiation(atom.indicator)); + } else if (!pl.type.is_callable(grbody)) { + thread.throw_error(pl.error.type("callable", grbody, atom.indicator)); + } else { + var goal = body_to_dcg(grbody.clone(), s0, thread); + goal.value = new Term(":", [new Term(context_module), new Term("call", [goal.value])]); + if (goal !== null) { + thread.prepend([new State( + point.goal.replace(new Term(",", [goal.value, new Term("=", [goal.variable, s])])), + point.substitution, + point + )]); + } + } + }, + "phrase/2": function(thread, point, atom) { + var grbody = atom.args[0], s0 = atom.args[1]; + thread.prepend([new State( + point.goal.replace(new Term("phrase", [grbody, s0, new Term("[]", [])])), + point.substitution, + point + )]); + }, + "version/0": function(thread, point, atom) { + var msg = "Welcome to Tau Prolog version " + version.major + "." + version.minor + "." + version.patch + "\n"; + msg += "Tau Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.\n"; + msg += "Please run ?- license. for legal details.\n"; + msg += "For online help and background, visit http:/tau-prolog.org"; + thread.prepend([new State( + point.goal.replace(new Term("write", [new Term(msg, [])])), + point.substitution, + point + )]); + }, + "license/0": function(thread, point, atom) { + var msg = "Tau Prolog. A Prolog interpreter in JavaScript.\n"; + msg += "Copyright (C) 2017 - 2022 Jos\xE9 Antonio Riaza Valverde\n\n"; + msg += "Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n"; + msg += "1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n"; + msg += "2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n"; + msg += "3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n"; + msg += 'THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n'; + msg += "You should have received a copy of the BSD 3-Clause License along with this program. If not, see https://opensource.org/licenses/BSD-3-Clause"; + thread.prepend([new State( + point.goal.replace(new Term("write", [new Term(msg, [])])), + point.substitution, + point + )]); + } + }, "all", { + meta_predicates: { + "$findall/4": new Term("$findall", [new Term("?"), new Num(0, false), new Term("-"), new Term("?")]), + "$bagof/3": new Term("$bagof", [new Term("?"), new Term("^"), new Term("-")]), + "$setof/3": new Term("$setof", [new Term("?"), new Term("^"), new Term("-")]), + "$if/3": new Term("$if", [new Num(0, false), new Num(0, false), new Num(0, false)]), + ";/2": new Term(";", [new Num(0, false), new Num(0, false)]), + "->/2": new Term("->", [new Num(0, false), new Num(0, false)]), + "*->/2": new Term("*->", [new Num(0, false), new Num(0, false)]), + "\\+/1": new Term("\\+", [new Num(0, false)]), + "abolish/1": new Term("abolish", [new Term(":")]), + "asserta/1": new Term("asserta", [new Term(":")]), + "assertz/1": new Term("assertz", [new Term(":")]), + "bagof/3": new Term("bagof", [new Term("?"), new Term("^"), new Term("-")]), + "call/1": new Term("call", [new Num(0, false)]), + "call/2": new Term("call", [new Num(1, false), new Term("?")]), + "call/3": new Term("call", [new Num(2, false), new Term("?"), new Term("?")]), + "call/4": new Term("call", [new Num(3, false), new Term("?"), new Term("?"), new Term("?")]), + "call/5": new Term("call", [new Num(4, false), new Term("?"), new Term("?"), new Term("?"), new Term("?")]), + "call/6": new Term("call", [new Num(5, false), new Term("?"), new Term("?"), new Term("?"), new Term("?"), new Term("?")]), + "call/7": new Term("call", [new Num(6, false), new Term("?"), new Term("?"), new Term("?"), new Term("?"), new Term("?"), new Term("?")]), + "call/8": new Term("call", [new Num(6, false), new Term("?"), new Term("?"), new Term("?"), new Term("?"), new Term("?"), new Term("?"), new Term("?")]), + "call_cleanup/2": new Term("call_cleanup", [new Num(0, false), new Num(0, false)]), + "catch/3": new Term("catch", [new Num(0, false), new Term("?"), new Num(0, false)]), + "consult/1": new Term("consult", [new Term(":")]), + "clause/2": new Term("clause", [new Term(":"), new Term("?")]), + "current_predicate/2": new Term("current_predicate", [new Term("?"), new Term(":")]), + "findall/3": new Term("findall", [new Term("?"), new Num(0, false), new Term("-")]), + "findall/4": new Term("findall", [new Term("?"), new Num(0, false), new Term("-"), new Term("?")]), + "forall/2": new Term("forall", [new Num(0, false), new Num(0, false)]), + "listing/1": new Term("listing", [new Term(":")]), + "once/1": new Term("once", [new Num(0, false)]), + "phrase/2": new Term("phrase", [new Term(":"), new Term("?")]), + "phrase/3": new Term("phrase", [new Term(":"), new Term("?"), new Term("?")]), + "retract/1": new Term("retract", [new Term(":")]), + "retractall/1": new Term("retractall", [new Term(":")]), + "setup_call_cleanup/3": new Term("setup_call_cleanup", [new Num(0, false), new Num(0, false), new Num(0, false)]), + "setof/3": new Term("setof", [new Term("?"), new Term("^"), new Term("-")]) + } + }); + if (typeof module2 !== "undefined") { + module2.exports = pl; + } else { + window.pl = pl; + } + })(); + } +}); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + canonicalLanguages: () => canonicalLanguages, + default: () => ExecuteCodePlugin2, + languageAliases: () => languageAliases, + runButtonClass: () => runButtonClass, + supportedLanguages: () => supportedLanguages +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian44 = require("obsidian"); + +// src/Outputter.ts +var import_events = require("events"); + +// src/svgs/parseHTML.ts +var parseHTML_default = (html) => { + let container = document.createElement("div"); + container.innerHTML = html; + return container.firstElementChild; +}; + +// src/svgs/loadEllipses.ts +var svg = parseHTML_default(` + + + + +`); +var loadEllipses_default = () => { + return svg.cloneNode(true); +}; + +// src/svgs/loadSpinner.ts +var svg2 = parseHTML_default(` + + + `); +var loadSpinner_default = () => { + return svg2.cloneNode(true); +}; + +// src/Outputter.ts +var TOGGLE_HTML_SIGIL = `TOGGLE_HTML_${Math.random().toString(16).substring(2)}`; +var Outputter = class extends import_events.EventEmitter { + constructor(codeBlock, doInput) { + super(); + this.inputState = doInput ? "INACTIVE" : "NOT_DOING"; + this.codeBlockElement = codeBlock; + this.hadPreviouslyPrinted = false; + this.escapeHTML = true; + this.htmlBuffer = ""; + this.blockRunState = "INITIAL"; + } + clear() { + if (this.outputElement) { + for (const child of Array.from(this.outputElement.children)) { + if (child instanceof HTMLSpanElement) + this.outputElement.removeChild(child); + } + } + this.lastPrintElem = null; + this.hadPreviouslyPrinted = false; + this.lastPrinted = ""; + if (this.clearButton) + this.clearButton.className = "clear-button-disabled"; + this.closeInput(); + this.inputState = "INACTIVE"; + this.killBlock(); + } + killBlock() { + } + delete() { + if (this.outputElement) + this.outputElement.style.display = "none"; + this.clear(); + } + write(text) { + this.processSigilsAndWriteText(text); + } + processSigilsAndWriteText(text) { + while (true) { + let index = text.indexOf(TOGGLE_HTML_SIGIL); + if (index === -1) + break; + if (index > 0) + this.writeRaw(text.substring(0, index)); + this.escapeHTML = !this.escapeHTML; + this.writeHTMLBuffer(this.addStdout()); + text = text.substring(index + TOGGLE_HTML_SIGIL.length); + } + this.writeRaw(text); + } + writeRaw(text) { + text = text.replace(/\x1b\\[;\d]*m/g, ""); + if (this.textPrinted(text)) { + this.escapeAwareAppend(this.addStdout(), text); + this.makeOutputVisible(); + } + } + writeErr(text) { + text = text.replace(/\x1b\\[;\d]*m/g, ""); + if (this.textPrinted(text)) { + this.addStderr().appendText(text); + this.makeOutputVisible(); + } + } + closeInput() { + this.inputState = "CLOSED"; + if (this.inputElement) + this.inputElement.style.display = "none"; + } + startBlock() { + if (!this.loadStateIndicatorElement) + this.addLoadStateIndicator(); + setTimeout(() => { + if (this.blockRunState !== "FINISHED") + this.loadStateIndicatorElement.classList.add("visible"); + }, 100); + this.loadStateIndicatorElement.empty(); + this.loadStateIndicatorElement.appendChild(loadSpinner_default()); + this.loadStateIndicatorElement.setAttribute("aria-label", "This block is running.\nClick to stop."); + this.blockRunState = "RUNNING"; + } + queueBlock() { + if (!this.loadStateIndicatorElement) + this.addLoadStateIndicator(); + setTimeout(() => { + if (this.blockRunState !== "FINISHED") + this.loadStateIndicatorElement.classList.add("visible"); + }, 100); + this.loadStateIndicatorElement.empty(); + this.loadStateIndicatorElement.appendChild(loadEllipses_default()); + this.loadStateIndicatorElement.setAttribute("aria-label", "This block is waiting for another block to finish.\nClick to cancel."); + this.blockRunState = "QUEUED"; + } + finishBlock() { + if (this.loadStateIndicatorElement) { + this.loadStateIndicatorElement.classList.remove("visible"); + } + this.blockRunState = "FINISHED"; + } + addLoadStateIndicator() { + this.loadStateIndicatorElement = document.createElement("div"); + this.loadStateIndicatorElement.classList.add("load-state-indicator"); + this.loadStateIndicatorElement.addEventListener("click", () => this.killBlock()); + this.getParentElement().parentElement.appendChild(this.loadStateIndicatorElement); + } + getParentElement() { + return this.codeBlockElement.parentElement; + } + addClearButton() { + const parentEl = this.getParentElement(); + this.clearButton = document.createElement("button"); + this.clearButton.className = "clear-button"; + this.clearButton.setText("Clear"); + this.clearButton.addEventListener("click", () => this.delete()); + parentEl.appendChild(this.clearButton); + } + addOutputElement() { + const parentEl = this.getParentElement(); + const hr = document.createElement("hr"); + this.outputElement = document.createElement("code"); + this.outputElement.classList.add("language-output"); + this.outputElement.appendChild(hr); + if (this.inputState != "NOT_DOING") + this.addInputElement(); + parentEl.appendChild(this.outputElement); + } + addInputElement() { + this.inputElement = document.createElement("input"); + this.inputElement.classList.add("interactive-stdin"); + this.inputElement.addEventListener("keypress", (e) => { + if (e.key == "Enter") { + this.processInput(this.inputElement.value + "\n"); + this.inputElement.value = ""; + } + }); + this.outputElement.appendChild(this.inputElement); + } + processInput(input) { + this.addStdin().appendText(input); + this.emit("data", input); + } + addStdin() { + return this.addStreamSegmentElement("stdin"); + } + addStderr() { + return this.addStreamSegmentElement("stderr"); + } + addStdout() { + return this.addStreamSegmentElement("stdout"); + } + addStreamSegmentElement(streamId) { + if (!this.outputElement) + this.addOutputElement(); + if (this.lastPrintElem) { + if (this.lastPrintElem.classList.contains(streamId)) + return this.lastPrintElem; + } + const stdElem = document.createElement("span"); + stdElem.addClass(streamId); + if (this.inputElement) { + this.outputElement.insertBefore(stdElem, this.inputElement); + } else { + this.outputElement.appendChild(stdElem); + } + this.lastPrintElem = stdElem; + return stdElem; + } + escapeAwareAppend(element, text) { + if (this.escapeHTML) { + element.appendChild(document.createTextNode(text)); + } else { + this.htmlBuffer += text; + } + } + writeHTMLBuffer(element) { + if (this.htmlBuffer !== "") { + this.makeOutputVisible(); + const content = document.createElement("div"); + content.innerHTML = this.htmlBuffer; + for (const childElem of Array.from(content.childNodes)) + element.appendChild(childElem); + this.htmlBuffer = ""; + } + } + textPrinted(text) { + if (this.hadPreviouslyPrinted) + return true; + if (text.contains(TOGGLE_HTML_SIGIL)) + return false; + if (text === "") + return false; + this.hadPreviouslyPrinted = true; + return true; + } + makeOutputVisible() { + this.closeInput(); + if (!this.clearButton) + this.addClearButton(); + if (!this.outputElement) + this.addOutputElement(); + this.inputState = "OPEN"; + this.outputElement.style.display = "block"; + this.clearButton.className = "clear-button"; + setTimeout(() => { + if (this.inputState === "OPEN") + this.inputElement.style.display = "inline"; + }, 1e3); + } +}; + +// src/settings/Settings.ts +var DEFAULT_SETTINGS = { + lastOpenLanguageTab: void 0, + timeout: 1e4, + allowInput: true, + wslMode: false, + shellWSLMode: false, + onlyCurrentBlock: false, + nodePath: "node", + nodeArgs: "", + jsFileExtension: "js", + jsInject: "", + tsPath: "ts-node", + tsArgs: "", + tsInject: "", + leanPath: "lean", + leanArgs: "", + leanInject: "", + luaPath: "lua", + luaArgs: "", + luaFileExtension: "lua", + luaInject: "", + dartPath: "dart", + dartArgs: "", + dartFileExtension: "dart", + dartInject: "", + csPath: "dotnet-script", + csArgs: "", + csFileExtension: "csx", + csInject: "", + pythonPath: "python", + pythonArgs: "", + pythonEmbedPlots: true, + pythonFileExtension: "py", + pythonInject: "", + shellPath: "bash", + shellArgs: "", + shellFileExtension: "sh", + shellInject: "", + batchPath: "call", + batchArgs: "", + batchFileExtension: "bat", + batchInject: "", + groovyPath: "groovy", + groovyArgs: "", + groovyFileExtension: "groovy", + groovyInject: "", + golangPath: "go", + golangArgs: "run", + golangFileExtension: "go", + goInject: "", + javaPath: "java", + javaArgs: "-ea", + javaFileExtension: "java", + javaInject: "", + maxPrologAnswers: 15, + prologInject: "", + powershellPath: "powershell", + powershellArgs: "-file", + powershellFileExtension: "ps1", + powershellInject: "$OutputEncoding = [console]::InputEncoding = [console]::OutputEncoding = New-Object System.Text.UTF8Encoding", + powershellEncoding: "latin1", + cargoPath: "cargo", + cargoEvalArgs: "", + rustInject: "", + cppRunner: "cling", + cppFileExtension: "cpp", + cppInject: "", + cppArgs: "", + cppUseMain: false, + clingPath: "cling", + clingArgs: "", + clingStd: "c++17", + rustFileExtension: "rs", + RPath: "Rscript", + RArgs: "", + REmbedPlots: true, + RFileExtension: "R", + rInject: "", + kotlinPath: "kotlinc", + kotlinArgs: "-script", + kotlinFileExtension: "kts", + kotlinInject: "", + swiftPath: "swift", + swiftArgs: "", + swiftFileExtension: "swift", + swiftInject: "", + runghcPath: "runghc", + ghcPath: "ghc", + ghciPath: "ghci", + useGhci: false, + haskellInject: "", + mathematicaPath: "wolframscript", + mathematicaArgs: "-file", + mathematicaFileExtension: "wls", + mathematicaInject: "", + scalaPath: "scala", + scalaArgs: "", + scalaFileExtension: "scala", + scalaInject: "", + racketPath: "racket", + racketArgs: "", + racketFileExtension: "rkt", + racketInject: "#lang racket", + fsharpPath: "dotnet", + fsharpArgs: "", + fsharpInject: "", + fsharpFileExtension: "fsx", + cArgs: "", + cUseMain: true, + cInject: "", + rubyPath: "ruby", + rubyArgs: "", + rubyFileExtension: "rb", + rubyInject: "", + sqlPath: "psql", + sqlArgs: "-d -U -f", + sqlInject: "", + octavePath: "octave", + octaveArgs: "-q", + octaveFileExtension: "m", + octaveInject: "figure('visible','off') # Necessary to embed plots", + maximaPath: "maxima", + maximaArgs: "-qb", + maximaFileExtension: "mx", + maximaInject: "", + applescriptPath: "osascript", + applescriptArgs: "", + applescriptFileExtension: "scpt", + applescriptInject: "", + zigPath: "zig", + zigArgs: "run", + zigInject: "", + ocamlPath: "ocaml", + ocamlArgs: "", + ocamlInject: "", + jsInteractive: true, + tsInteractive: false, + csInteractive: false, + leanInteractive: false, + luaInteractive: false, + dartInteractive: false, + pythonInteractive: true, + cppInteractive: false, + prologInteractive: false, + shellInteractive: false, + batchInteractive: false, + bashInteractive: false, + groovyInteractive: false, + rInteractive: false, + goInteractive: false, + rustInteractive: false, + javaInteractive: false, + powershellInteractive: false, + kotlinInteractive: false, + swiftInteractive: false, + mathematicaInteractive: false, + haskellInteractive: false, + scalaInteractive: false, + fsharpInteractive: false, + cInteractive: false, + racketInteractive: false, + rubyInteractive: false, + sqlInteractive: false, + octaveInteractive: false, + maximaInteractive: false, + applescriptInteractive: false, + zigInteractive: false, + ocamlInteractive: false +}; + +// src/settings/SettingsTab.ts +var import_obsidian33 = require("obsidian"); + +// src/settings/languageDisplayName.ts +var DISPLAY_NAMES = { + cpp: "C++", + cs: "C#", + go: "Golang", + groovy: "Groovy", + haskell: "Haskell", + java: "Java", + js: "Javascript", + kotlin: "Kotlin", + lua: "Lua", + mathematica: "Mathematica", + powershell: "Powershell", + prolog: "Prolog", + python: "Python", + r: "R", + rust: "Rust", + shell: "Shell", + batch: "Batch", + ts: "Typescript", + scala: "Scala", + swift: "Swift", + racket: "Racket", + c: "C", + fsharp: "F#", + ruby: "Ruby", + dart: "Dart", + lean: "Lean", + sql: "SQL", + octave: "Octave", + maxima: "Maxima", + applescript: "Applescript", + zig: "Zig", + ocaml: "OCaml" +}; + +// src/settings/per-lang/makeCppSettings.ts +var import_obsidian = require("obsidian"); +var makeCppSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "C++ Settings" }); + new import_obsidian.Setting(containerEl).setName("Cling path").setDesc("The path to your Cling installation.").addText((text) => text.setValue(tab.plugin.settings.clingPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.clingPath = sanitized; + console.log("Cling path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Cling arguments for C++").addText((text) => text.setValue(tab.plugin.settings.cppArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.cppArgs = value; + console.log("CPP args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Cling std").addDropdown((dropdown) => dropdown.addOption("c++98", "C++ 98").addOption("c++11", "C++ 11").addOption("c++14", "C++ 14").addOption("c++17", "C++ 17").addOption("c++2a", "C++ 20").setValue(tab.plugin.settings.clingStd).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.clingStd = value; + console.log("Cling std set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Use main function").setDesc("If enabled, will use a main() function as the code block entrypoint.").addToggle((toggle) => toggle.setValue(tab.plugin.settings.cppUseMain).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.cppUseMain = value; + console.log("Cpp use main set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "cpp"); +}; + +// src/settings/per-lang/makeCSettings.ts +var import_obsidian2 = require("obsidian"); +var makeCSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "C Settings" }); + new import_obsidian2.Setting(containerEl).setName("gcc / Cling path").setDesc("The path to your gcc / Cling installation.").addText((text) => text.setValue(tab.plugin.settings.clingPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.clingPath = sanitized; + console.log("gcc / Cling path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian2.Setting(containerEl).setName("gcc / Cling arguments for C").addText((text) => text.setValue(tab.plugin.settings.cArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.cArgs = value; + console.log("gcc / Cling args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian2.Setting(containerEl).setName("Cling std (ignored for gcc)").addDropdown((dropdown) => dropdown.addOption("c++98", "C++ 98").addOption("c++11", "C++ 11").addOption("c++14", "C++ 14").addOption("c++17", "C++ 17").addOption("c++2a", "C++ 20").setValue(tab.plugin.settings.clingStd).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.clingStd = value; + console.log("Cling std set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian2.Setting(containerEl).setName("Use main function (mandatory for gcc)").setDesc("If enabled, will use a main() function as the code block entrypoint.").addToggle((toggle) => toggle.setValue(tab.plugin.settings.cUseMain).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.cUseMain = value; + console.log("C use main set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "c"); +}; + +// src/settings/per-lang/makeCsSettings.ts +var import_obsidian3 = require("obsidian"); +var makeCsSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "CSharp Settings" }); + new import_obsidian3.Setting(containerEl).setName("dotnet path").addText((text) => text.setValue(tab.plugin.settings.csPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.csPath = sanitized; + console.log("dotnet path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian3.Setting(containerEl).setName("CSharp arguments").addText((text) => text.setValue(tab.plugin.settings.csArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.csArgs = value; + console.log("CSharp args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "cs"); +}; + +// src/settings/per-lang/makeFSharpSettings.ts +var import_obsidian4 = require("obsidian"); +var makeFSharpSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "F# Settings" }); + new import_obsidian4.Setting(containerEl).setName("F# path").setDesc("The path to dotnet.").addText((text) => text.setValue(tab.plugin.settings.fsharpPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.fsharpPath = sanitized; + console.log("F# path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian4.Setting(containerEl).setName("F# arguments").addText((text) => text.setValue(tab.plugin.settings.fsharpArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.fsharpArgs = value; + console.log("F# args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian4.Setting(containerEl).setName("F# file extension").setDesc("Changes the file extension for generated F# scripts.").addText((text) => text.setValue(tab.plugin.settings.fsharpFileExtension).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.fsharpFileExtension = value; + console.log("F# file extension set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "fsharp"); +}; + +// src/settings/per-lang/makeGoSettings.ts +var import_obsidian5 = require("obsidian"); +var makeGoSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Golang Settings" }); + new import_obsidian5.Setting(containerEl).setName("Golang Path").setDesc("The path to your Golang installation.").addText((text) => text.setValue(tab.plugin.settings.golangPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.golangPath = sanitized; + console.log("Golang path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "go"); +}; + +// src/settings/per-lang/makeGroovySettings.ts +var import_obsidian6 = require("obsidian"); +var makeGroovySettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Groovy Settings" }); + new import_obsidian6.Setting(containerEl).setName("Groovy path").setDesc("The path to your Groovy installation.").addText((text) => text.setValue(tab.plugin.settings.groovyPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.groovyPath = sanitized; + console.log("Groovy path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian6.Setting(containerEl).setName("Groovy arguments").addText((text) => text.setValue(tab.plugin.settings.groovyArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.groovyArgs = value; + console.log("Groovy args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "groovy"); +}; + +// src/settings/per-lang/makeHaskellSettings.ts +var import_obsidian7 = require("obsidian"); +var makeHaskellSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Haskell Settings" }); + new import_obsidian7.Setting(containerEl).setName("Use Ghci").setDesc("Run haskell code with ghci instead of runghc").addToggle((toggle) => toggle.setValue(tab.plugin.settings.useGhci).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.useGhci = value; + console.log(value ? "Now using ghci for haskell" : "Now using runghc for haskell."); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian7.Setting(containerEl).setName("Ghci path").setDesc("The path to your ghci installation.").addText((text) => text.setValue(tab.plugin.settings.ghciPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.ghciPath = sanitized; + console.log("ghci path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian7.Setting(containerEl).setName("Rungch path").setDesc("The path to your runghc installation.").addText((text) => text.setValue(tab.plugin.settings.runghcPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.runghcPath = sanitized; + console.log("runghc path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian7.Setting(containerEl).setName("Ghc path").setDesc("The Ghc path your runghc installation will call.").addText((text) => text.setValue(tab.plugin.settings.ghcPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.ghcPath = sanitized; + console.log("ghc path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "haskell"); +}; + +// src/settings/per-lang/makeJavaSettings.ts +var import_obsidian8 = require("obsidian"); +var makeJavaSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Java Settings" }); + new import_obsidian8.Setting(containerEl).setName("Java path (Java 11 or higher)").setDesc("The path to your Java installation.").addText((text) => text.setValue(tab.plugin.settings.javaPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.javaPath = sanitized; + console.log("Java path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian8.Setting(containerEl).setName("Java arguments").addText((text) => text.setValue(tab.plugin.settings.javaArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.javaArgs = value; + console.log("Java args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "java"); +}; + +// src/settings/per-lang/makeJsSettings.ts +var import_obsidian9 = require("obsidian"); +var makeJsSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "JavaScript / Node Settings" }); + new import_obsidian9.Setting(containerEl).setName("Node path").addText((text) => text.setValue(tab.plugin.settings.nodePath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.nodePath = sanitized; + console.log("Node path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian9.Setting(containerEl).setName("Node arguments").addText((text) => text.setValue(tab.plugin.settings.nodeArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.nodeArgs = value; + console.log("Node args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian9.Setting(containerEl).setName("Run Javascript blocks in Notebook Mode").addToggle( + (toggle) => toggle.setValue(tab.plugin.settings.jsInteractive).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.jsInteractive = value; + yield tab.plugin.saveSettings(); + })) + ); + tab.makeInjectSetting(containerEl, "js"); +}; + +// src/settings/per-lang/makeKotlinSettings.ts +var import_obsidian10 = require("obsidian"); +var makeKotlinSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Kotlin Settings" }); + new import_obsidian10.Setting(containerEl).setName("Kotlin path").setDesc("The path to your Kotlin installation.").addText((text) => text.setValue(tab.plugin.settings.kotlinPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.kotlinPath = sanitized; + console.log("Kotlin path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian10.Setting(containerEl).setName("Kotlin arguments").addText((text) => text.setValue(tab.plugin.settings.kotlinArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.kotlinArgs = value; + console.log("Kotlin args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "kotlin"); +}; + +// src/settings/per-lang/makeLeanSettings.ts +var import_obsidian11 = require("obsidian"); +var makeLeanSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Lean Settings" }); + new import_obsidian11.Setting(containerEl).setName("lean path").addText((text) => text.setValue(tab.plugin.settings.leanPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.leanPath = sanitized; + console.log("lean path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian11.Setting(containerEl).setName("Lean arguments").addText((text) => text.setValue(tab.plugin.settings.leanArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.leanArgs = value; + console.log("Lean args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "lean"); +}; + +// src/settings/per-lang/makeLuaSettings.ts +var import_obsidian12 = require("obsidian"); +var makeLuaSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Lua Settings" }); + new import_obsidian12.Setting(containerEl).setName("lua path").addText((text) => text.setValue(tab.plugin.settings.luaPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.luaPath = sanitized; + console.log("lua path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian12.Setting(containerEl).setName("Lua arguments").addText((text) => text.setValue(tab.plugin.settings.luaArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.luaArgs = value; + console.log("Lua args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "lua"); +}; + +// src/settings/per-lang/makeDartSettings.ts +var import_obsidian13 = require("obsidian"); +var makeDartSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Dart Settings" }); + new import_obsidian13.Setting(containerEl).setName("dart path").addText((text) => text.setValue(tab.plugin.settings.dartPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.dartPath = sanitized; + console.log("dart path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian13.Setting(containerEl).setName("Dart arguments").addText((text) => text.setValue(tab.plugin.settings.dartArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.dartArgs = value; + console.log("Dart args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "dart"); +}; + +// src/settings/per-lang/makeMathematicaSettings.ts +var import_obsidian14 = require("obsidian"); +var makeMathematicaSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Wolfram Mathematica Settings" }); + new import_obsidian14.Setting(containerEl).setName("Mathematica path").setDesc("The path to your Mathematica installation.").addText((text) => text.setValue(tab.plugin.settings.mathematicaPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.mathematicaPath = sanitized; + console.log("Mathematica path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian14.Setting(containerEl).setName("Mathematica arguments").addText((text) => text.setValue(tab.plugin.settings.mathematicaArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.mathematicaArgs = value; + console.log("Mathematica args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "mathematica"); +}; + +// src/settings/per-lang/makePowershellSettings.ts +var import_obsidian15 = require("obsidian"); +var makePowershellSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Powershell Settings" }); + new import_obsidian15.Setting(containerEl).setName("Powershell path").setDesc("The path to Powershell.").addText((text) => text.setValue(tab.plugin.settings.powershellPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.powershellPath = sanitized; + console.log("Powershell path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian15.Setting(containerEl).setName("Powershell arguments").addText((text) => text.setValue(tab.plugin.settings.powershellArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.powershellArgs = value; + console.log("Powershell args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian15.Setting(containerEl).setName("Powershell file extension").setDesc("Changes the file extension for generated shell scripts. This is useful if you don't want to use PowerShell.").addText((text) => text.setValue(tab.plugin.settings.powershellFileExtension).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.powershellFileExtension = value; + console.log("Powershell file extension set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian15.Setting(containerEl).setName("PowerShell script encoding").setDesc('Windows still uses windows-1252 as default encoding on most systems for legacy reasons. If you change your encodings systemwide to UTF-8, you can change this setting to UTF-8 as well. Only use one of the following encodings: "ascii", "utf8", "utf-8", "utf16le", "ucs2", "ucs-2", "base64", "latin1", "binary", "hex" (default: "latin1")').addText((text) => text.setValue(tab.plugin.settings.powershellEncoding).onChange((value) => __async(void 0, null, function* () { + value = value.replace(/["'`´]/, "").trim().toLowerCase(); + if (["ascii", "utf8", "utf-8", "utf16le", "ucs2", "ucs-2", "base64", "latin1", "binary", "hex"].includes(value)) { + tab.plugin.settings.powershellEncoding = value; + console.log("Powershell file extension set to: " + value); + yield tab.plugin.saveSettings(); + } else { + console.error("Invalid encoding. " + value + 'Please use one of the following encodings: "ascii", "utf8", "utf-8", "utf16le", "ucs2", "ucs-2", "base64", "latin1", "binary", "hex"'); + } + }))); + tab.makeInjectSetting(containerEl, "powershell"); +}; + +// src/settings/per-lang/makePrologSettings.ts +var import_obsidian16 = require("obsidian"); +var makePrologSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Prolog Settings" }); + new import_obsidian16.Setting(containerEl).setName("Prolog Answer Limit").setDesc("Maximal number of answers to be returned by the Prolog engine. tab is to prevent creating too huge texts in the notebook.").addText((text) => text.setValue("" + tab.plugin.settings.maxPrologAnswers).onChange((value) => __async(void 0, null, function* () { + if (Number(value) * 1e3) { + console.log("Prolog answer limit set to: " + value); + tab.plugin.settings.maxPrologAnswers = Number(value); + } + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "prolog"); +}; + +// src/settings/per-lang/makePythonSettings.ts +var import_obsidian17 = require("obsidian"); +var makePythonSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Python Settings" }); + new import_obsidian17.Setting(containerEl).setName("Embed Python Plots").addToggle((toggle) => toggle.setValue(tab.plugin.settings.pythonEmbedPlots).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.pythonEmbedPlots = value; + console.log(value ? "Embedding Plots into Notes." : "Not embedding Plots into Notes."); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian17.Setting(containerEl).setName("Python path").setDesc("The path to your Python installation.").addText((text) => text.setValue(tab.plugin.settings.pythonPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.pythonPath = sanitized; + console.log("Python path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian17.Setting(containerEl).setName("Python arguments").addText((text) => text.setValue(tab.plugin.settings.pythonArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.pythonArgs = value; + console.log("Python args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian17.Setting(containerEl).setName("Run Python blocks in Notebook Mode").addToggle((toggle) => toggle.setValue(tab.plugin.settings.pythonInteractive).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.pythonInteractive = value; + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "python"); +}; + +// src/settings/per-lang/makeRSettings.ts +var import_obsidian18 = require("obsidian"); +var makeRSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "R Settings" }); + new import_obsidian18.Setting(containerEl).setName("Embed R Plots created via `plot()` into Notes").addToggle((toggle) => toggle.setValue(tab.plugin.settings.REmbedPlots).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.REmbedPlots = value; + console.log(value ? "Embedding R Plots into Notes." : "Not embedding R Plots into Notes."); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian18.Setting(containerEl).setName("Rscript path").setDesc("The path to your Rscript installation. Ensure you provide the Rscript binary instead of the ordinary R binary.").addText((text) => text.setValue(tab.plugin.settings.RPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.RPath = sanitized; + console.log("R path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian18.Setting(containerEl).setName("R arguments").addText((text) => text.setValue(tab.plugin.settings.RArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.RArgs = value; + console.log("R args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian18.Setting(containerEl).setName("Run R blocks in Notebook Mode").addToggle((toggle) => toggle.setValue(tab.plugin.settings.rInteractive).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.rInteractive = value; + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "r"); +}; + +// src/settings/per-lang/makeRubySettings.ts +var import_obsidian19 = require("obsidian"); +var makeRubySettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Ruby Settings" }); + new import_obsidian19.Setting(containerEl).setName("ruby path").setDesc("Path to your ruby installation").addText((text) => text.setValue(tab.plugin.settings.rubyPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.rubyPath = sanitized; + console.log("ruby path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian19.Setting(containerEl).setName("ruby arguments").addText((text) => text.setValue(tab.plugin.settings.rubyArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.rubyArgs = value; + console.log("ruby args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "ruby"); +}; + +// src/settings/per-lang/makeRustSettings.ts +var import_obsidian20 = require("obsidian"); +var makeRustSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Rust Settings" }); + new import_obsidian20.Setting(containerEl).setName("Cargo Path").setDesc("The path to your Cargo installation.").addText((text) => text.setValue(tab.plugin.settings.cargoPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.cargoPath = sanitized; + console.log("Cargo path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "rust"); +}; + +// src/settings/per-lang/makeScalaSettings.ts +var import_obsidian21 = require("obsidian"); +var makeScalaSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Scala Settings" }); + new import_obsidian21.Setting(containerEl).setName("scala path").setDesc("Path to your scala installation").addText((text) => text.setValue(tab.plugin.settings.scalaPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.scalaPath = sanitized; + console.log("scala path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian21.Setting(containerEl).setName("Scala arguments").addText((text) => text.setValue(tab.plugin.settings.scalaArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.scalaArgs = value; + console.log("Scala args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "scala"); +}; + +// src/settings/per-lang/makeRacketSettings.ts +var import_obsidian22 = require("obsidian"); +var makeRacketSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Racket Settings" }); + new import_obsidian22.Setting(containerEl).setName("racket path").setDesc("Path to your racket installation").addText((text) => text.setValue(tab.plugin.settings.racketPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.racketPath = sanitized; + console.log("racket path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian22.Setting(containerEl).setName("Racket arguments").addText((text) => text.setValue(tab.plugin.settings.racketArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.racketArgs = value; + console.log("Racket args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "racket"); +}; + +// src/settings/per-lang/makeShellSettings.ts +var import_obsidian23 = require("obsidian"); +var makeShellSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Shell Settings" }); + new import_obsidian23.Setting(containerEl).setName("Shell path").setDesc("The path to shell. Default is Bash but you can use any shell you want, e.g. bash, zsh, fish, ...").addText((text) => text.setValue(tab.plugin.settings.shellPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.shellPath = sanitized; + console.log("Shell path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian23.Setting(containerEl).setName("Shell arguments").addText((text) => text.setValue(tab.plugin.settings.shellArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.shellArgs = value; + console.log("Shell args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian23.Setting(containerEl).setName("Shell file extension").setDesc("Changes the file extension for generated shell scripts. This is useful if you want to use a shell other than bash.").addText((text) => text.setValue(tab.plugin.settings.shellFileExtension).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.shellFileExtension = value; + console.log("Shell file extension set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian23.Setting(containerEl).setName("Shell WSL mode").setDesc('Run the shell script in Windows Subsystem for Linux. This option is used if the global "WSL Mode" is disabled.').addToggle( + (toggle) => toggle.setValue(tab.plugin.settings.shellWSLMode).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.shellWSLMode = value; + yield tab.plugin.saveSettings(); + })) + ); + tab.makeInjectSetting(containerEl, "shell"); +}; + +// src/settings/per-lang/makeBatchSettings.ts +var import_obsidian24 = require("obsidian"); +var makeBatchSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Batch Settings" }); + new import_obsidian24.Setting(containerEl).setName("Batch path").setDesc("The path to the terminal. Default is command prompt.").addText((text) => text.setValue(tab.plugin.settings.batchPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.batchPath = sanitized; + console.log("Batch path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian24.Setting(containerEl).setName("Batch arguments").addText((text) => text.setValue(tab.plugin.settings.batchArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.batchArgs = value; + console.log("Batch args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian24.Setting(containerEl).setName("Batch file extension").setDesc("Changes the file extension for generated batch scripts. Default is .bat").addText((text) => text.setValue(tab.plugin.settings.batchFileExtension).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.batchFileExtension = value; + console.log("Batch file extension set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "batch"); +}; + +// src/settings/per-lang/makeTsSettings.ts +var import_obsidian25 = require("obsidian"); +var makeTsSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "TypeScript Settings" }); + new import_obsidian25.Setting(containerEl).setName("ts-node path").addText((text) => text.setValue(tab.plugin.settings.tsPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.tsPath = sanitized; + console.log("ts-node path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian25.Setting(containerEl).setName("TypeScript arguments").addText((text) => text.setValue(tab.plugin.settings.tsArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.tsArgs = value; + console.log("TypeScript args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "ts"); +}; + +// src/settings/per-lang/makeSQLSettings.ts +var import_obsidian26 = require("obsidian"); +var makeSQLSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "SQL Settings" }); + new import_obsidian26.Setting(containerEl).setName("SQL path").setDesc("Path to your SQL installation. You can select the SQL dialect you prefer but you need to set the right arguments by yourself.").addText((text) => text.setValue(tab.plugin.settings.sqlPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.sqlPath = sanitized; + console.log("ruby path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian26.Setting(containerEl).setName("SQL arguments").setDesc("Set the right arguments for your database.").addText((text) => text.setValue(tab.plugin.settings.sqlArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.sqlArgs = value; + console.log("SQL args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "sql"); +}; + +// src/settings/per-lang/makeOctaveSettings.ts +var import_obsidian27 = require("obsidian"); +var makeOctaveSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Octave Settings" }); + new import_obsidian27.Setting(containerEl).setName("Octave path").setDesc("The path to your Octave installation.").addText((text) => text.setValue(tab.plugin.settings.octavePath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.octavePath = sanitized; + console.log("Octave path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian27.Setting(containerEl).setName("Octave arguments").addText((text) => text.setValue(tab.plugin.settings.octaveArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.octaveArgs = value; + console.log("Octave args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "octave"); +}; + +// src/settings/per-lang/makeMaximaSettings.ts +var import_obsidian28 = require("obsidian"); +var makeMaximaSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Maxima Settings" }); + new import_obsidian28.Setting(containerEl).setName("Maxima path").setDesc("The path to your Maxima installation.").addText((text) => text.setValue(tab.plugin.settings.maximaPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.maximaPath = sanitized; + console.log("Maxima path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian28.Setting(containerEl).setName("Maxima arguments").addText((text) => text.setValue(tab.plugin.settings.maximaArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.maximaArgs = value; + console.log("Maxima args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "maxima"); +}; + +// src/settings/per-lang/makeApplescriptSettings.ts +var import_obsidian29 = require("obsidian"); +var makeApplescriptSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Applescript Settings" }); + new import_obsidian29.Setting(containerEl).setName("Osascript path").setDesc("The path to your osascript installation (only available on MacOS).").addText((text) => text.setValue(tab.plugin.settings.applescriptPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.applescriptPath = sanitized; + console.log("Applescript path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian29.Setting(containerEl).setName("Applescript arguments").addText((text) => text.setValue(tab.plugin.settings.applescriptArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.applescriptArgs = value; + console.log("Applescript args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "applescript"); +}; + +// src/settings/per-lang/makeZigSettings.ts +var import_obsidian30 = require("obsidian"); +var makeZigSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Zig Settings" }); + new import_obsidian30.Setting(containerEl).setName("zig path").setDesc("Path to your zig installation").addText((text) => text.setValue(tab.plugin.settings.zigPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.zigPath = sanitized; + console.log("zig path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian30.Setting(containerEl).setName("zig arguments").addText((text) => text.setValue(tab.plugin.settings.zigArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.zigArgs = value; + console.log("zig args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "zig"); +}; + +// src/settings/per-lang/makeOCamlSettings.ts +var import_obsidian31 = require("obsidian"); +var makeOCamlSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "OCaml Settings" }); + new import_obsidian31.Setting(containerEl).setName("ocaml path").setDesc("Path to your ocaml installation").addText((text) => text.setValue(tab.plugin.settings.ocamlPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.ocamlPath = sanitized; + console.log("ocaml path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian31.Setting(containerEl).setName("ocaml arguments").addText((text) => text.setValue(tab.plugin.settings.ocamlArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.ocamlArgs = value; + console.log("ocaml args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "ocaml"); +}; + +// src/settings/per-lang/makeSwiftSettings.ts +var import_obsidian32 = require("obsidian"); +var makeSwiftSettings_default = (tab, containerEl) => { + containerEl.createEl("h3", { text: "Swift Settings" }); + new import_obsidian32.Setting(containerEl).setName("Swift path").setDesc("The path to your Swift installation.").addText((text) => text.setValue(tab.plugin.settings.swiftPath).onChange((value) => __async(void 0, null, function* () { + const sanitized = tab.sanitizePath(value); + tab.plugin.settings.swiftPath = sanitized; + console.log("Swift path set to: " + sanitized); + yield tab.plugin.saveSettings(); + }))); + new import_obsidian32.Setting(containerEl).setName("Swift arguments").addText((text) => text.setValue(tab.plugin.settings.swiftArgs).onChange((value) => __async(void 0, null, function* () { + tab.plugin.settings.swiftArgs = value; + console.log("Swift args set to: " + value); + yield tab.plugin.saveSettings(); + }))); + tab.makeInjectSetting(containerEl, "swift"); +}; + +// src/settings/SettingsTab.ts +var SettingsTab = class extends import_obsidian33.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + this.languageContainers = {}; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Settings for the Code Execution Plugin." }); + containerEl.createEl("h3", { text: "General Settings" }); + new import_obsidian33.Setting(containerEl).setName("Timeout (in seconds)").setDesc("The time after which a program gets shut down automatically. This is to prevent infinite loops. ").addText((text) => text.setValue("" + this.plugin.settings.timeout / 1e3).onChange((value) => __async(this, null, function* () { + if (Number(value) * 1e3) { + console.log("Timeout set to: " + value); + this.plugin.settings.timeout = Number(value) * 1e3; + } + yield this.plugin.saveSettings(); + }))); + new import_obsidian33.Setting(containerEl).setName("Allow Input").setDesc("Whether or not to include a stdin input box when running blocks. In order to apply changes to this, Obsidian must be refreshed. ").addToggle((text) => text.setValue(this.plugin.settings.allowInput).onChange((value) => __async(this, null, function* () { + console.log("Allow Input set to: " + value); + this.plugin.settings.allowInput = value; + yield this.plugin.saveSettings(); + }))); + if (process.platform === "win32") { + new import_obsidian33.Setting(containerEl).setName("WSL Mode").setDesc("Whether or not to run code in the Windows Subsystem for Linux. If you don't have WSL installed, don't turn this on!").addToggle((text) => text.setValue(this.plugin.settings.wslMode).onChange((value) => __async(this, null, function* () { + console.log("WSL Mode set to: " + value); + this.plugin.settings.wslMode = value; + yield this.plugin.saveSettings(); + }))); + } + new import_obsidian33.Setting(containerEl).setName("Only Current Log").setDesc("Whether or not show print log only in current code block.").addToggle((text) => text.setValue(this.plugin.settings.onlyCurrentBlock).onChange((value) => __async(this, null, function* () { + console.log("Only Show Current Block Log set to: " + value); + this.plugin.settings.onlyCurrentBlock = value; + yield this.plugin.saveSettings(); + }))); + containerEl.createEl("hr"); + new import_obsidian33.Setting(containerEl).setName("Language-Specific Settings").setDesc("Pick a language to edit its language-specific settings").addDropdown( + (dropdown) => dropdown.addOptions(Object.fromEntries( + canonicalLanguages.map((lang) => [lang, DISPLAY_NAMES[lang]]) + )).setValue(this.plugin.settings.lastOpenLanguageTab || canonicalLanguages[0]).onChange((value) => __async(this, null, function* () { + this.focusContainer(value); + this.plugin.settings.lastOpenLanguageTab = value; + yield this.plugin.saveSettings(); + })) + ).settingEl.style.borderTop = "0"; + makeJsSettings_default(this, this.makeContainerFor("js")); + makeTsSettings_default(this, this.makeContainerFor("ts")); + makeLeanSettings_default(this, this.makeContainerFor("lean")); + makeLuaSettings_default(this, this.makeContainerFor("lua")); + makeDartSettings_default(this, this.makeContainerFor("dart")); + makeCsSettings_default(this, this.makeContainerFor("cs")); + makeJavaSettings_default(this, this.makeContainerFor("java")); + makePythonSettings_default(this, this.makeContainerFor("python")); + makeGoSettings_default(this, this.makeContainerFor("go")); + makeRustSettings_default(this, this.makeContainerFor("rust")); + makeCppSettings_default(this, this.makeContainerFor("cpp")); + makeCSettings_default(this, this.makeContainerFor("c")); + makeBatchSettings_default(this, this.makeContainerFor("batch")); + makeShellSettings_default(this, this.makeContainerFor("shell")); + makePowershellSettings_default(this, this.makeContainerFor("powershell")); + makePrologSettings_default(this, this.makeContainerFor("prolog")); + makeGroovySettings_default(this, this.makeContainerFor("groovy")); + makeRSettings_default(this, this.makeContainerFor("r")); + makeKotlinSettings_default(this, this.makeContainerFor("kotlin")); + makeMathematicaSettings_default(this, this.makeContainerFor("mathematica")); + makeHaskellSettings_default(this, this.makeContainerFor("haskell")); + makeScalaSettings_default(this, this.makeContainerFor("scala")); + makeSwiftSettings_default(this, this.makeContainerFor("swift")); + makeRacketSettings_default(this, this.makeContainerFor("racket")); + makeFSharpSettings_default(this, this.makeContainerFor("fsharp")); + makeRubySettings_default(this, this.makeContainerFor("ruby")); + makeSQLSettings_default(this, this.makeContainerFor("sql")); + makeOctaveSettings_default(this, this.makeContainerFor("octave")); + makeMaximaSettings_default(this, this.makeContainerFor("maxima")); + makeApplescriptSettings_default(this, this.makeContainerFor("applescript")); + makeZigSettings_default(this, this.makeContainerFor("zig")); + makeOCamlSettings_default(this, this.makeContainerFor("ocaml")); + this.focusContainer(this.plugin.settings.lastOpenLanguageTab || canonicalLanguages[0]); + } + makeContainerFor(language) { + const container = this.containerEl.createDiv(); + container.style.display = "none"; + this.languageContainers[language] = container; + return container; + } + focusContainer(language) { + if (this.activeLanguageContainer) + this.activeLanguageContainer.style.display = "none"; + if (language in this.languageContainers) { + this.activeLanguageContainer = this.languageContainers[language]; + this.activeLanguageContainer.style.display = "block"; + } + } + sanitizePath(path2) { + path2 = path2.replace(/\\/g, "/"); + path2 = path2.replace(/['"`]/, ""); + path2 = path2.trim(); + return path2; + } + makeInjectSetting(containerEl, language) { + const languageAlt = DISPLAY_NAMES[language]; + new import_obsidian33.Setting(containerEl).setName(`Inject ${languageAlt} code`).setDesc(`Code to add to the top of every ${languageAlt} code block before running.`).setClass("settings-code-input-box").addTextArea((textarea) => { + const val = this.plugin.settings[`${language}Inject`]; + return textarea.setValue(val).onChange((value) => __async(this, null, function* () { + this.plugin.settings[`${language}Inject`] = value; + console.log(`${language} inject set to ${value}`); + yield this.plugin.saveSettings(); + })); + }); + } +}; + +// src/transforms/Magic.ts +var os = __toESM(require("os")); +var import_obsidian34 = require("obsidian"); +var SHOW_REGEX = new RegExp(`@show\\(["'](?[^<>?*=!\\n#()\\[\\]{}]+)["'](,\\s*(?\\d+[\\w%]+),?\\s*(?\\d+[\\w%]+))?(,\\s*(?left|center|right))?\\)`, "g"); +var HTML_REGEX = new RegExp("@html\\((?[^)]+)\\)", "g"); +var VAULT_REGEX = /@vault/g; +var VAULT_PATH_REGEX = /@vault_path/g; +var VAULT_URL_REGEX = /@vault_url/g; +var CURRENT_NOTE_REGEX = /@note/g; +var CURRENT_NOTE_PATH_REGEX = /@note_path/g; +var CURRENT_NOTE_URL_REGEX = /@note_url/g; +var NOTE_TITLE_REGEX = /@title/g; +var COLOR_THEME_REGEX = /@theme/g; +var PYTHON_PLOT_REGEX = /^(plt|matplotlib.pyplot|pyplot)\.show\(\)/gm; +var R_PLOT_REGEX = /^plot\(.*\)/gm; +var OCTAVE_PLOT_REGEX = /^plot\s*\(.*\);/gm; +var MAXIMA_PLOT_REGEX = /^plot2d\s*\(.*\[.+\]\)\s*[$;]/gm; +function insertVaultPath(source, vaultPath) { + source = source.replace(VAULT_PATH_REGEX, `"${vaultPath.replace(/\\/g, "/")}"`); + source = source.replace(VAULT_URL_REGEX, `"${import_obsidian34.Platform.resourcePathPrefix + vaultPath.replace(/\\/g, "/")}"`); + source = source.replace(VAULT_REGEX, `"${import_obsidian34.Platform.resourcePathPrefix + vaultPath.replace(/\\/g, "/")}"`); + return source; +} +function insertNotePath(source, notePath) { + source = source.replace(CURRENT_NOTE_PATH_REGEX, `"${notePath.replace(/\\/g, "/")}"`); + source = source.replace(CURRENT_NOTE_URL_REGEX, `"${import_obsidian34.Platform.resourcePathPrefix + notePath.replace(/\\/g, "/")}"`); + source = source.replace(CURRENT_NOTE_REGEX, `"${import_obsidian34.Platform.resourcePathPrefix + notePath.replace(/\\/g, "/")}"`); + return source; +} +function insertNoteTitle(source, noteTitle) { + let t = ""; + if (noteTitle.contains(".")) + t = noteTitle.split(".").slice(0, -1).join("."); + return source.replace(NOTE_TITLE_REGEX, `"${t}"`); +} +function insertColorTheme(source, theme) { + return source.replace(COLOR_THEME_REGEX, `"${theme}"`); +} +function addMagicToPython(source) { + source = pythonParseShowImage(source); + source = pythonParseHtmlFunction(source); + return source; +} +function addMagicToJS(source) { + source = jsParseShowImage(source); + source = jsParseHtmlFunction(source); + return source; +} +function addInlinePlotsToPython(source, toggleHtmlSigil) { + const showPlot = `import io; import sys; __obsidian_execute_code_temp_pyplot_var__=io.BytesIO(); plt.plot(); plt.savefig(__obsidian_execute_code_temp_pyplot_var__, format='svg'); plt.close(); sys.stdout.write(${JSON.stringify(toggleHtmlSigil)}); sys.stdout.flush(); sys.stdout.buffer.write(__obsidian_execute_code_temp_pyplot_var__.getvalue()); sys.stdout.flush(); sys.stdout.write(${JSON.stringify(toggleHtmlSigil)}); sys.stdout.flush()`; + return source.replace(PYTHON_PLOT_REGEX, showPlot); +} +function addInlinePlotsToR(source) { + const matches = source.matchAll(R_PLOT_REGEX); + for (const match of matches) { + const tempFile = `${os.tmpdir()}/temp_${Date.now()}.png`.replace(/\\/g, "/"); + const substitute = `png("${tempFile}"); ${match[0]}; dev.off(); cat('${TOGGLE_HTML_SIGIL}${TOGGLE_HTML_SIGIL}')`; + source = source.replace(match[0], substitute); + } + return source; +} +function pythonParseShowImage(source) { + const matches = source.matchAll(SHOW_REGEX); + for (const match of matches) { + const imagePath = match.groups.path; + const width = match.groups.width; + const height = match.groups.height; + const alignment = match.groups.align; + const image = buildMagicShowImage(imagePath.replace(/\\/g, "\\\\"), width, height, alignment); + source = source.replace(match[0], "print('" + TOGGLE_HTML_SIGIL + image + TOGGLE_HTML_SIGIL + "')"); + } + return source; +} +function pythonParseHtmlFunction(source) { + const matches = source.matchAll(HTML_REGEX); + for (const match of matches) { + const html = match.groups.html; + const toggle = JSON.stringify(TOGGLE_HTML_SIGIL); + source = source.replace(match[0], `print(${toggle}); print(${html}); print(${toggle})`); + } + return source; +} +function jsParseShowImage(source) { + const matches = source.matchAll(SHOW_REGEX); + for (const match of matches) { + const imagePath = match.groups.path; + const width = match.groups.width; + const height = match.groups.height; + const alignment = match.groups.align; + const image = buildMagicShowImage(imagePath.replace(/\\/g, "\\\\"), width, height, alignment); + source = source.replace(match[0], "console.log('" + TOGGLE_HTML_SIGIL + image + TOGGLE_HTML_SIGIL + "')"); + console.log(source); + } + return source; +} +function jsParseHtmlFunction(source) { + const matches = source.matchAll(HTML_REGEX); + for (const match of matches) { + const html = match.groups.html; + const toggle = JSON.stringify(TOGGLE_HTML_SIGIL); + source = source.replace(match[0], `console.log(${toggle}); console.log(${html}); console.log(${toggle})`); + } + return source; +} +function buildMagicShowImage(imagePath, width = "0", height = "0", alignment = "center") { + if (imagePath.contains("+")) { + let splittedPath = imagePath.replace(/['"]/g, "").split("+"); + splittedPath = splittedPath.map((element) => element.trim()); + imagePath = splittedPath.join(""); + } + if (width == "0" || height == "0") + return `Image found at path ${imagePath}.`; + return `Image found at path ${imagePath}.`; +} +function addInlinePlotsToOctave(source) { + const matches = source.matchAll(OCTAVE_PLOT_REGEX); + for (const match of matches) { + const tempFile = `${os.tmpdir()}/temp_${Date.now()}.png`.replace(/\\/g, "/"); + const substitute = `${match[0]}; print -dpng ${tempFile}; disp('${TOGGLE_HTML_SIGIL}${TOGGLE_HTML_SIGIL}');`; + source = source.replace(match[0], substitute); + } + return source; +} +function addInlinePlotsToMaxima(source) { + const matches = source.matchAll(MAXIMA_PLOT_REGEX); + for (const match of matches) { + const tempFile = `${os.tmpdir()}/temp_${Date.now()}.png`.replace(/\\/g, "/"); + const updated_plot_call = match[0].substring(0, match[0].lastIndexOf(")")) + `, [png_file, "${tempFile}"])`; + const substitute = `${updated_plot_call}; print ('${TOGGLE_HTML_SIGIL}${TOGGLE_HTML_SIGIL}');`; + source = source.replace(match[0], substitute); + } + return source; +} + +// src/Vault.ts +var import_obsidian35 = require("obsidian"); +function getVaultVariables(app) { + const activeView = app.workspace.getActiveViewOfType(import_obsidian35.MarkdownView); + if (activeView === null) { + return null; + } + const adapter = app.vault.adapter; + const vaultPath = adapter.getBasePath(); + const folder = activeView.file.parent.path; + const fileName = activeView.file.name; + const filePath = activeView.file.path; + const theme = document.body.classList.contains("theme-light") ? "light" : "dark"; + return { + vaultPath, + folder, + fileName, + filePath, + theme + }; +} + +// src/transforms/TransformCode.ts +function getLanguageAlias(language) { + if (language === void 0) + return void 0; + switch (language) { + case "javascript": + return "js"; + case "typescript": + return "ts"; + case "csharp": + return "cs"; + case "bash": + return "shell"; + case "py": + return "python"; + case "wolfram": + return "mathematica"; + case "nb": + return "mathematica"; + case "wl": + "mathematica"; + case "hs": + return "haskell"; + } + if (canonicalLanguages.includes(language)) + return language; + return void 0; +} +function transformMagicCommands(app, srcCode) { + let ret = srcCode; + const vars = getVaultVariables(app); + if (vars) { + ret = insertVaultPath(ret, vars.vaultPath); + ret = insertNotePath(ret, vars.filePath); + ret = insertNoteTitle(ret, vars.fileName); + ret = insertColorTheme(ret, vars.theme); + } else { + console.warn(`Could not load all Vault variables! ${vars}`); + } + return ret; +} +function getCodeBlockLanguage(firstLineOfCode) { + let currentLanguage = firstLineOfCode.split("```")[1].trim().split(" ")[0].split("{")[0]; + if (isStringNotEmpty(currentLanguage) && currentLanguage.startsWith("run-")) { + currentLanguage = currentLanguage.replace("run-", ""); + } + return getLanguageAlias(currentLanguage); +} +function isStringNotEmpty(str) { + return !!str && str.trim().length > 0; +} + +// src/transforms/CodeInjector.ts +var import_obsidian37 = require("obsidian"); + +// src/CodeBlockArgs.ts +var import_obsidian36 = require("obsidian"); +var JSON5 = __toESM(require_dist()); +function getArgs(firstLineOfCode) { + if (!firstLineOfCode.contains("{") && !firstLineOfCode.contains("}")) + return {}; + try { + let args = firstLineOfCode.substring(firstLineOfCode.indexOf("{") + 1).trim(); + args = args.replace(/=/g, ":"); + const exports = []; + const handleUnnamedExport = (exportName) => { + let i2 = args.indexOf(exportName); + while (i2 !== -1) { + const nextChar = args[i2 + exportName.length]; + if (nextChar !== `"` && nextChar !== `'`) { + args = args.substring(0, i2) + args.substring(i2 + exportName.length + (nextChar === "}" ? 0 : 1)); + exports.push(exportName); + } + i2 = args.indexOf(exportName, i2 + 1); + } + }; + handleUnnamedExport("pre"); + handleUnnamedExport("post"); + args = `{export: ['${exports.join("', '")}'], ${args}`; + return JSON5.parse(args); + } catch (err) { + new import_obsidian36.Notice(`Failed to parse code block arguments from line: +${firstLineOfCode} + +Failed with error: +${err}`); + return {}; + } +} + +// src/transforms/CodeInjector.ts +var CodeInjector = class { + constructor(app, settings, language) { + this.prependSrcCode = ""; + this.appendSrcCode = ""; + this.namedImportSrcCode = ""; + this.mainArgs = {}; + this.namedExports = {}; + this.app = app; + this.settings = settings; + this.language = language; + } + injectCode(srcCode) { + return __async(this, null, function* () { + const language = getLanguageAlias(this.language); + const activeView = this.app.workspace.getActiveViewOfType(import_obsidian37.MarkdownView); + if (activeView === null) + return srcCode; + yield this.parseFile(activeView.data, srcCode, language); + const realLanguage = /[^-]*$/.exec(language)[0]; + const globalInject = this.settings[`${realLanguage}Inject`]; + let injectedCode = `${this.namedImportSrcCode} +${srcCode}`; + if (!this.mainArgs.ignore) + injectedCode = `${globalInject} +${this.prependSrcCode} +${injectedCode} +${this.appendSrcCode}`; + else { + if (!Array.isArray(this.mainArgs.ignore) && this.mainArgs.ignore !== "all") + this.mainArgs.ignore = [this.mainArgs.ignore]; + if (this.mainArgs.ignore !== "all") { + if (!this.mainArgs.ignore.contains("pre")) + injectedCode = `${this.prependSrcCode} +${injectedCode}`; + if (!this.mainArgs.ignore.contains("post")) + injectedCode = `${injectedCode} +${this.appendSrcCode}`; + if (!this.mainArgs.ignore.contains("global")) + injectedCode = `${globalInject} +${injectedCode}`; + } + } + return transformMagicCommands(this.app, injectedCode); + }); + } + handleNamedImports(namedImports) { + return __async(this, null, function* () { + const handleNamedImport = (namedImport) => { + if (!this.namedExports.hasOwnProperty(namedImport)) { + new import_obsidian37.Notice(`Named export "${namedImport}" does not exist but was imported`); + return true; + } + this.namedImportSrcCode += `${this.disable_print(this.namedExports[namedImport])} +`; + return false; + }; + if (!Array.isArray(namedImports)) + return handleNamedImport(namedImports); + for (const namedImport of namedImports) { + const err = handleNamedImport(namedImport); + if (err) + return true; + } + return false; + }); + } + parseFile(fileContents, srcCode, language) { + return __async(this, null, function* () { + let currentArgs = {}; + let insideCodeBlock = false; + let isLanguageEqual = false; + let currentLanguage = ""; + let currentCode = ""; + let currentFirstLine = ""; + for (const line of fileContents.split("\n")) { + if (line.startsWith("```")) { + if (insideCodeBlock) { + const srcCodeTrimmed = srcCode.trim(); + const currentCodeTrimmed = currentCode.trim(); + if (isLanguageEqual && srcCodeTrimmed.length === currentCodeTrimmed.length && srcCodeTrimmed === currentCodeTrimmed) { + this.mainArgs = getArgs(currentFirstLine); + if (this.mainArgs.import) { + const err = this.handleNamedImports(this.mainArgs.import); + if (err) + return ""; + } + break; + } + if (currentArgs.label) { + if (this.namedExports.hasOwnProperty(currentArgs.label)) { + new import_obsidian37.Notice(`Error: named export ${currentArgs.label} exported more than once`); + return ""; + } + this.namedExports[currentArgs.label] = currentCode; + } + if (!Array.isArray(currentArgs.export)) + currentArgs.export = [currentArgs.export]; + if (currentArgs.export.contains("pre")) + this.prependSrcCode += `${this.disable_print(currentCode)} +`; + if (currentArgs.export.contains("post")) + this.appendSrcCode += `${this.disable_print(currentCode)} +`; + currentLanguage = ""; + currentCode = ""; + insideCodeBlock = false; + currentArgs = {}; + } else { + currentLanguage = getCodeBlockLanguage(line); + isLanguageEqual = /[^-]*$/.exec(language)[0] === /[^-]*$/.exec(currentLanguage)[0]; + if (isLanguageEqual) { + currentArgs = getArgs(line); + currentFirstLine = line; + } + insideCodeBlock = true; + } + } else if (insideCodeBlock && isLanguageEqual) { + currentCode += `${line} +`; + } + } + }); + } + disable_print(code) { + if (!this.settings.onlyCurrentBlock) { + return code; + } + const pattern = /^print\s*(.*)/gm; + return code.replace(pattern, " "); + } +}; + +// src/ExecutorContainer.ts +var import_events2 = require("events"); + +// src/executors/ReplExecutor.ts +var import_child_process2 = require("child_process"); +var import_obsidian39 = require("obsidian"); + +// src/executors/Executor.ts +var import_obsidian38 = require("obsidian"); +var os2 = __toESM(require("os")); +var path = __toESM(require("path")); +var import_stream = require("stream"); +var Executor = class extends import_stream.EventEmitter { + constructor(file, language) { + super(); + this.tempFileId = void 0; + this.file = file; + this.language = language; + } + notifyError(cmd, cmdArgs, tempFileName, err, outputter, label = "Error while executing code") { + const errorMSG = `Error while executing ${cmd} ${cmdArgs} ${tempFileName}: ${err}`; + console.error(errorMSG); + if (outputter) + outputter.writeErr(errorMSG); + new import_obsidian38.Notice(label); + } + getTempFile(ext) { + if (this.tempFileId === void 0) + this.tempFileId = Date.now().toString(); + return path.join(os2.tmpdir(), `temp_${this.tempFileId}.${ext}`); + } +}; + +// src/executors/AsyncExecutor.ts +var AsyncExecutor = class extends Executor { + constructor() { + super(...arguments); + this.runningTask = Promise.resolve(); + } + addJobToQueue(promiseCallback) { + return __async(this, null, function* () { + const previousJob = this.runningTask; + this.runningTask = new Promise((resolve, reject) => { + previousJob.finally(() => __async(this, null, function* () { + try { + yield new Promise((innerResolve, innerReject) => { + this.once("close", () => innerResolve(void 0)); + promiseCallback(innerResolve, innerReject); + }); + resolve(); + } catch (e) { + reject(e); + } + })); + }); + return this.runningTask; + }); + } +}; + +// src/executors/killWithChildren.ts +var import_child_process = require("child_process"); +var killWithChildren_default = (pid) => { + if (process.platform === "win32") { + (0, import_child_process.execSync)(`taskkill /pid ${pid} /T /F`); + } else { + try { + (0, import_child_process.execSync)(`pkill -P ${pid}`); + } catch (err) { + if (err.status !== 1) + throw err; + } + process.kill(pid); + } +}; + +// src/executors/ReplExecutor.ts +var ReplExecutor = class extends AsyncExecutor { + constructor(settings, path2, args, file, language) { + var _a; + super(file, language); + this.settings = settings; + if (this.settings.wslMode) { + args.unshift("-e", path2); + path2 = "wsl"; + } + if (path2.includes("%USERNAME%") && ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.USERNAME)) + path2 = path2.replace("%USERNAME%", process.env.USERNAME); + this.process = (0, import_child_process2.spawn)(path2, args, { env: process.env }); + this.process.on("close", () => { + this.emit("close"); + new import_obsidian39.Notice("Runtime exited"); + this.process = null; + }); + this.process.on("error", (err) => { + this.notifyError(settings.pythonPath, args.join(" "), "", err, void 0, "Error launching process: " + err); + this.stop(); + }); + this.setup().then(() => { + }); + } + run(code, outputter, cmd, cmdArgs, ext) { + outputter.queueBlock(); + return this.addJobToQueue((resolve, _reject) => { + if (this.process === null) + return resolve(); + const finishSigil = `SIGIL_BLOCK_DONE_${Math.random()}_${Date.now()}_${code.length}`; + outputter.startBlock(); + const wrappedCode = this.wrapCode(code, finishSigil); + this.process.stdin.write(wrappedCode); + outputter.clear(); + outputter.on("data", (data) => { + this.process.stdin.write(data); + }); + const writeToStdout = (data) => { + let str = data.toString(); + if (str.endsWith(finishSigil)) { + str = str.substring(0, str.length - finishSigil.length); + this.process.stdout.removeListener("data", writeToStdout); + this.process.stderr.removeListener("data", writeToStderr); + this.process.removeListener("close", resolve); + outputter.write(str); + resolve(); + } else { + outputter.write(str); + } + }; + const writeToStderr = (data) => { + outputter.writeErr( + this.removePrompts(data.toString(), "stderr") + ); + }; + this.process.on("close", resolve); + this.process.stdout.on("data", writeToStdout); + this.process.stderr.on("data", writeToStderr); + }); + } + stop() { + return new Promise((resolve, _reject) => { + this.process.on("close", () => { + resolve(); + }); + killWithChildren_default(this.process.pid); + this.process = null; + }); + } +}; + +// src/executors/NodeJSExecutor.ts +var NodeJSExecutor = class extends ReplExecutor { + constructor(settings, file) { + const args = settings.nodeArgs ? settings.nodeArgs.split(" ") : []; + args.unshift(`-e`, `require("repl").start({prompt: "", preview: false, ignoreUndefined: true}).on("exit", ()=>process.exit())`); + super(settings, settings.nodePath, args, file, "js"); + } + setup() { + return __async(this, null, function* () { + this.process.stdin.write("\n"); + }); + } + wrapCode(code, finishSigil) { + return `try { eval(${JSON.stringify(code)}); }catch(e) { console.error(e); }finally { process.stdout.write(${JSON.stringify(finishSigil)}); } +`; + } + removePrompts(output, source) { + return output; + } +}; + +// src/executors/NonInteractiveCodeExecutor.ts +var import_obsidian40 = require("obsidian"); +var fs = __toESM(require("fs")); +var child_process = __toESM(require("child_process")); + +// src/transforms/windowsPathToWsl.ts +var import_posix = require("path/posix"); +var import_path = require("path"); +var windowsPathToWsl_default = (windowsPath) => { + const driveLetter = windowsPath[0].toLowerCase(); + const posixyPath = windowsPath.replace(/^[^:]*:/, "").split(import_path.sep).join("/"); + return (0, import_posix.join)("/mnt/", driveLetter, posixyPath); +}; + +// src/executors/NonInteractiveCodeExecutor.ts +var NonInteractiveCodeExecutor = class extends Executor { + constructor(settings, usesShell, file, language) { + super(file, language); + this.resolveRun = void 0; + this.settings = settings; + this.usesShell = usesShell; + } + stop() { + return Promise.resolve(); + } + run(codeBlockContent, outputter, cmd, cmdArgs, ext) { + if (this.resolveRun !== void 0) + this.resolveRun(); + this.resolveRun = void 0; + return new Promise((resolve, reject) => { + const tempFileName = this.getTempFile(ext); + fs.promises.writeFile(tempFileName, codeBlockContent).then(() => { + const args = cmdArgs ? cmdArgs.split(" ") : []; + if (this.isWSLEnabled()) { + args.unshift("-e", cmd); + cmd = "wsl"; + args.push(windowsPathToWsl_default(tempFileName)); + } else { + args.push(tempFileName); + } + let child; + if (cmd.endsWith("gcc") || cmd.endsWith("gcc.exe")) { + const tempFileNameWExe = tempFileName.slice(0, -2) + ".out"; + args.push("-o", tempFileNameWExe); + const childGCC = child_process.spawn(cmd, args, { env: process.env, shell: this.usesShell }); + this.handleChildOutput(childGCC, outputter, tempFileName); + childGCC.on("exit", (code) => { + if (code === 0) { + child = child_process.spawn(tempFileNameWExe, { env: process.env, shell: this.usesShell }); + this.handleChildOutput(child, outputter, tempFileNameWExe).then(() => { + this.tempFileId = void 0; + }); + } + }); + } else { + child = child_process.spawn(cmd, args, { env: process.env, shell: this.usesShell }); + this.handleChildOutput(child, outputter, tempFileName).then(() => { + this.tempFileId = void 0; + }); + } + this.resolveRun = resolve; + }).catch((err) => { + this.notifyError(cmd, cmdArgs, tempFileName, err, outputter); + resolve(); + }); + }); + } + isWSLEnabled() { + if (this.settings.wslMode) { + return true; + } + if (this.language == "shell" && this.settings.shellWSLMode) { + return true; + } + return false; + } + handleChildOutput(child, outputter, fileName) { + return __async(this, null, function* () { + outputter.clear(); + outputter.killBlock = () => { + child.kill("SIGINT"); + }; + this.stdoutCb = (data) => { + outputter.write(data.toString()); + }; + this.stderrCb = (data) => { + outputter.writeErr(data.toString()); + }; + child.stdout.on("data", this.stdoutCb); + child.stderr.on("data", this.stderrCb); + outputter.on("data", (data) => { + child.stdin.write(data); + }); + child.on("close", (code) => { + if (code !== 0) + new import_obsidian40.Notice("Error!"); + if (this.resolveRun !== void 0) + this.resolveRun(); + outputter.closeInput(); + if (fileName === void 0) + return; + fs.promises.rm(fileName).catch((err) => { + console.error("Error in 'Obsidian Execute Code' Plugin while removing file: " + err); + }); + }); + child.on("error", (err) => { + new import_obsidian40.Notice("Error!"); + outputter.writeErr(err.toString()); + }); + }); + } +}; + +// src/executors/PrologExecutor.ts +var prolog = __toESM(require_core()); +var import_obsidian41 = require("obsidian"); +var PrologExecutor = class extends Executor { + constructor(settings, file) { + super(file, "prolog"); + this.runQueries = true; + this.maxPrologAnswers = settings.maxPrologAnswers; + } + run(code, outputter, cmd, cmdArgs, ext) { + return __async(this, null, function* () { + const prologCode = code.split(/\n+%+\s*query\n+/); + if (prologCode.length < 2) + return; + outputter.closeInput(); + outputter.clear(); + this.runPrologCode(prologCode[0], prologCode[1], outputter); + }); + } + stop() { + return __async(this, null, function* () { + this.runQueries = false; + this.emit("close"); + }); + } + runPrologCode(facts, queries, out) { + new import_obsidian41.Notice("Running..."); + const session = prolog.create(); + session.consult( + facts, + { + success: () => { + session.query( + queries, + { + success: (goal) => __async(this, null, function* () { + console.debug(`Prolog goal: ${goal}`); + let answersLeft = true; + let counter = 0; + while (answersLeft && counter < this.maxPrologAnswers) { + yield session.answer({ + success: function(answer) { + new import_obsidian41.Notice("Done!"); + console.debug(`Prolog result: ${session.format_answer(answer)}`); + out.write(session.format_answer(answer) + "\n"); + out.closeInput(); + }, + fail: function() { + answersLeft = false; + }, + error: function(err) { + new import_obsidian41.Notice("Error!"); + console.error(err); + answersLeft = false; + out.writeErr(`Error while executing code: ${err}`); + out.closeInput(); + }, + limit: function() { + answersLeft = false; + } + }); + counter++; + } + }), + error: (err) => { + new import_obsidian41.Notice("Error!"); + out.writeErr("Query failed.\n"); + out.writeErr(err.toString()); + } + } + ); + }, + error: (err) => { + out.writeErr("Adding facts failed.\n"); + out.writeErr(err.toString()); + } + } + ); + } +}; + +// src/executors/python/wrapPython.ts +var PLT_DEFAULT_BACKEND_PY_VAR = "OBSIDIAN_EXECUTE_CODE_MATPLOTLIB_DEFAULT_BACKEND"; +var wrapPython_default = (code, globalsName, printName, finishSigil, embedPlots) => ` +${embedPlots ? ` +try: + matplotlib.use('agg') +except: + pass +` : ` +try: + matplotlib.use(${PLT_DEFAULT_BACKEND_PY_VAR}) +except: + pass +`} + +try: + try: + ${printName}(eval( + compile(${JSON.stringify(code.replace(/\r\n/g, "\n") + "\n")}, "", "eval"), + ${globalsName} + )) + except SyntaxError: + exec( + compile(${JSON.stringify(code.replace(/\r\n/g, "\n") + "\n")}, "", "exec"), + ${globalsName} + ) +except Exception as e: + ${printName} (e, file=sys.stderr) +finally: + ${printName} ("${finishSigil}", end="") + +`; + +// src/executors/python/PythonExecutor.ts +var PythonExecutor = class extends ReplExecutor { + constructor(settings, file) { + const args = settings.pythonArgs ? settings.pythonArgs.split(" ") : []; + args.unshift("-i"); + super( + settings, + settings.pythonPath, + args, + file, + "python" + ); + this.printFunctionName = `__print_${Math.random().toString().substring(2)}_${Date.now()}`; + this.globalsDictionaryName = `__globals_${Math.random().toString().substring(2)}_${Date.now()}`; + } + removePrompts(output, source) { + if (source == "stderr") { + return output.replace(/(^((\.\.\.|>>>) )+)|(((\.\.\.|>>>) )+$)/g, ""); + } else { + return output; + } + } + wrapCode(code, finishSigil) { + return wrapPython_default( + code, + this.globalsDictionaryName, + this.printFunctionName, + finishSigil, + this.settings.pythonEmbedPlots + ); + } + setup() { + return __async(this, null, function* () { + this.addJobToQueue((resolve, reject) => { + this.process.stdin.write( + ` +${this.globalsDictionaryName} = {**globals()} +${this.settings.pythonEmbedPlots ? ` +try: + import matplotlib + ${PLT_DEFAULT_BACKEND_PY_VAR} = matplotlib.get_backend() +except: + pass +` : ""} + +from __future__ import print_function +import sys +${this.printFunctionName} = print +`.replace(/\r\n/g, "\n") + ); + this.process.stderr.once("data", (data) => { + resolve(); + }); + }).then(() => { + }); + }); + } +}; + +// src/executors/ClingExecutor.ts +var child_process2 = __toESM(require("child_process")); +var ClingExecutor = class extends NonInteractiveCodeExecutor { + constructor(settings, file, language) { + super(settings, false, file, language); + } + run(codeBlockContent, outputter, cmd, args, ext) { + if (this.settings[`${this.language}UseMain`]) { + this.getTempFile(ext); + let code; + if (ext != "c") { + code = codeBlockContent.replace(/main\(\)/g, `temp_${this.tempFileId}()`); + } else { + code = codeBlockContent; + } + return super.run(code, outputter, this.settings.clingPath, args, ext); + } + return new Promise((resolve, reject) => { + const childArgs = [...args.split(" "), ...codeBlockContent.split("\n")]; + const child = child_process2.spawn(this.settings.clingPath, childArgs, { env: process.env, shell: this.usesShell }); + this.resolveRun = resolve; + this.handleChildOutput(child, outputter, this.tempFileId); + }); + } + handleChildOutput(child, outputter, fileName) { + return __async(this, null, function* () { + __superGet(ClingExecutor.prototype, this, "handleChildOutput").call(this, child, outputter, fileName); + child.stdout.removeListener("data", this.stdoutCb); + child.stderr.removeListener("data", this.stderrCb); + const fileId = this.tempFileId; + const replaceTmpId = (data) => { + return data.replace(new RegExp(`temp_${fileId}\\(\\)`, "g"), "main()"); + }; + child.stdout.on("data", (data) => { + this.stdoutCb(replaceTmpId(data.toString())); + }); + child.stderr.on("data", (data) => { + this.stderrCb(replaceTmpId(data.toString())); + }); + }); + } +}; + +// src/executors/CppExecutor.ts +var CppExecutor = class extends ClingExecutor { + constructor(settings, file) { + super(settings, file, "cpp"); + } + run(codeBlockContent, outputter, cmd, cmdArgs, ext) { + return super.run(codeBlockContent, outputter, cmd, `-std=${this.settings.clingStd} ${cmdArgs}`, "cpp"); + } +}; + +// src/executors/RExecutor.ts +var RExecutor = class extends ReplExecutor { + constructor(settings, file) { + const args = settings.RArgs ? settings.RArgs.split(" ") : []; + let conArgName = `notebook_connection_${Math.random().toString(16).substring(2)}`; + args.unshift( + `-e`, + `${conArgName}=file("stdin", "r"); while(1) { eval(parse(text=tail(readLines(con = ${conArgName}, n=1)))) }` + ); + super(settings, settings.RPath, args, file, "r"); + } + setup() { + return __async(this, null, function* () { + console.log("setup"); + }); + } + wrapCode(code, finishSigil) { + return `tryCatch({ + cat(sprintf("%s", + eval(parse(text = ${JSON.stringify(code)} )) + )) + }, + error = function(e){ + cat(sprintf("%s", e), file=stderr()) + }, + finally = { + cat(${JSON.stringify(finishSigil)}); + flush.console() + })`.replace(/\r?\n/g, "") + "\n"; + } + removePrompts(output, source) { + return output; + } +}; + +// src/executors/CExecutor.ts +var CExecutor = class extends ClingExecutor { + constructor(settings, file) { + super(settings, file, "c"); + } + run(codeBlockContent, outputter, cmd, cmdArgs, ext) { + const install_path = this.settings[`clingPath`]; + if (install_path.endsWith("cling") || install_path.endsWith("cling.exe")) { + return super.run(codeBlockContent, outputter, cmd, this.settings[`cArgs`], "cpp"); + } else { + return super.run(codeBlockContent, outputter, cmd, this.settings[`cArgs`], "c"); + } + } +}; + +// src/executors/FSharpExecutor.ts +var FSharpExecutor = class extends NonInteractiveCodeExecutor { + constructor(settings, file) { + super(settings, false, file, "fsharp"); + } + run(codeBlockContent, outputter, cmd, args, ext) { + return super.run(codeBlockContent, outputter, cmd, `fsi ${args}`, "cpp"); + } +}; + +// src/ExecutorContainer.ts +var interactiveExecutors = { + "js": NodeJSExecutor, + "python": PythonExecutor, + "r": RExecutor +}; +var nonInteractiveExecutors = { + "prolog": PrologExecutor, + "cpp": CppExecutor, + "c": CExecutor, + "fsharp": FSharpExecutor +}; +var ExecutorContainer = class extends import_events2.EventEmitter { + constructor(plugin) { + super(); + this.executors = {}; + this.plugin = plugin; + window.addEventListener("beforeunload", () => __async(this, null, function* () { + for (const executor of this) { + executor.stop(); + } + })); + } + *[Symbol.iterator]() { + for (const language in this.executors) { + for (const file in this.executors[language]) { + yield this.executors[language][file]; + } + } + } + getExecutorFor(file, language, needsShell) { + if (!this.executors[language]) + this.executors[language] = {}; + if (!this.executors[language][file]) + this.setExecutorInExecutorsObject(file, language, needsShell); + return this.executors[language][file]; + } + setExecutorInExecutorsObject(file, language, needsShell) { + const exe = this.createExecutorFor(file, language, needsShell); + if (!(exe instanceof NonInteractiveCodeExecutor)) + this.emit("add", exe); + exe.on("close", () => { + delete this.executors[language][file]; + }); + this.executors[language][file] = exe; + } + createExecutorFor(file, language, needsShell) { + if (this.plugin.settings[`${language}Interactive`]) { + if (!(language in interactiveExecutors)) + throw new Error(`Attempted to use interactive executor for '${language}' but no such executor exists`); + return new interactiveExecutors[language](this.plugin.settings, file); + } else if (language in nonInteractiveExecutors) + return new nonInteractiveExecutors[language](this.plugin.settings, file); + return new NonInteractiveCodeExecutor(this.plugin.settings, needsShell, file, language); + } +}; + +// src/ExecutorManagerView.ts +var import_obsidian42 = require("obsidian"); +var import_path2 = require("path"); +var EXECUTOR_MANAGER_VIEW_ID = "code-execute-manage-executors"; +var EXECUTOR_MANAGER_OPEN_VIEW_COMMAND_ID = "code-execute-open-manage-executors"; +var ExecutorManagerView = class extends import_obsidian42.ItemView { + constructor(leaf, executors) { + super(leaf); + this.executors = executors; + this.executors.on("add", (executor) => { + this.addExecutorElement(executor); + }); + } + static activate(workspace) { + return __async(this, null, function* () { + workspace.detachLeavesOfType(EXECUTOR_MANAGER_VIEW_ID); + yield workspace.getRightLeaf(false).setViewState({ + type: EXECUTOR_MANAGER_VIEW_ID, + active: true + }); + workspace.revealLeaf( + workspace.getLeavesOfType(EXECUTOR_MANAGER_VIEW_ID)[0] + ); + }); + } + getViewType() { + return EXECUTOR_MANAGER_VIEW_ID; + } + getDisplayText() { + return "Execution Runtimes"; + } + getIcon() { + return "command-glyph"; + } + onOpen() { + return __async(this, null, function* () { + const container = this.contentEl; + container.empty(); + container.classList.add("manage-executors-view"); + const header = document.createElement("h3"); + header.textContent = "Runtimes"; + container.appendChild(header); + this.list = document.createElement("ul"); + container.appendChild(document.createElement("div")).appendChild(this.list); + for (const executor of this.executors) { + this.addExecutorElement(executor); + } + this.addEmptyState(); + }); + } + onClose() { + return __async(this, null, function* () { + }); + } + addEmptyState() { + this.emptyStateElement = document.createElement("div"); + this.emptyStateElement.classList.add("empty-state"); + this.emptyStateElement.textContent = "There are currently no runtimes online. Run some code blocks, and their runtimes will appear here."; + this.list.parentElement.appendChild(this.emptyStateElement); + this.updateEmptyState(); + } + updateEmptyState() { + if (this.list.childElementCount == 0) { + this.emptyStateElement.style.display = "block"; + } else { + this.emptyStateElement.style.display = "none"; + } + } + addExecutorElement(executor) { + const li = document.createElement("li"); + const simpleName = (0, import_path2.basename)(executor.file); + const langElem = document.createElement("small"); + langElem.textContent = executor.language; + li.appendChild(langElem); + li.appendChild(this.createFilenameRowElem(simpleName)); + executor.on("close", () => { + li.remove(); + this.updateEmptyState(); + }); + const button = document.createElement("button"); + button.addEventListener("click", () => executor.stop()); + (0, import_obsidian42.setIcon)(button, "trash"); + button.setAttribute("aria-label", "Stop Runtime"); + li.appendChild(button); + this.list.appendChild(li); + this.updateEmptyState(); + } + createFilenameRowElem(text) { + const fElem = document.createElement("span"); + fElem.textContent = text; + fElem.classList.add("filename"); + return fElem; + } +}; + +// src/runAllCodeBlocks.ts +var import_obsidian43 = require("obsidian"); +function runAllCodeBlocks(workspace) { + const lastActiveView = workspace.getMostRecentLeaf().view; + if (lastActiveView instanceof import_obsidian43.TextFileView) { + lastActiveView.containerEl.querySelectorAll("button." + runButtonClass).forEach((button) => { + button.click(); + }); + } +} + +// src/main.ts +var languageAliases = ["javascript", "typescript", "bash", "csharp", "wolfram", "nb", "wl", "hs", "py"]; +var canonicalLanguages = [ + "js", + "ts", + "cs", + "lean", + "lua", + "python", + "cpp", + "prolog", + "shell", + "groovy", + "r", + "go", + "rust", + "java", + "powershell", + "kotlin", + "mathematica", + "haskell", + "scala", + "swift", + "racket", + "fsharp", + "c", + "dart", + "ruby", + "batch", + "sql", + "octave", + "maxima", + "applescript", + "zig", + "ocaml" +]; +var supportedLanguages = [...languageAliases, ...canonicalLanguages]; +var buttonText = "Run"; +var runButtonClass = "run-code-button"; +var runButtonDisabledClass = "run-button-disabled"; +var hasButtonClass = "has-run-code-button"; +var ExecuteCodePlugin2 = class extends import_obsidian44.Plugin { + onload() { + return __async(this, null, function* () { + yield this.loadSettings(); + this.addSettingTab(new SettingsTab(this.app, this)); + this.executors = new ExecutorContainer(this); + this.iterateOpenFilesAndAddRunButtons(); + this.registerMarkdownPostProcessor((element, _context) => { + this.addRunButtons(element, _context.sourcePath); + }); + supportedLanguages.forEach((l) => { + console.debug(`Registering renderer for ${l}.`); + this.registerMarkdownCodeBlockProcessor(`run-${l}`, (src, el, _ctx) => __async(this, null, function* () { + yield import_obsidian44.MarkdownRenderer.renderMarkdown("```" + l + "\n" + src + (src.endsWith("\n") ? "" : "\n") + "```", el, _ctx.sourcePath, null); + })); + }); + this.registerView( + EXECUTOR_MANAGER_VIEW_ID, + (leaf) => new ExecutorManagerView(leaf, this.executors) + ); + this.addCommand({ + id: EXECUTOR_MANAGER_OPEN_VIEW_COMMAND_ID, + name: "Open Code Runtime Management", + callback: () => ExecutorManagerView.activate(this.app.workspace) + }); + this.addCommand({ + id: "run-all-code-blocks-in-file", + name: "Run all Code Blocks in Current File", + callback: () => runAllCodeBlocks(this.app.workspace) + }); + }); + } + onunload() { + document.querySelectorAll("pre > code").forEach((codeBlock) => { + const pre = codeBlock.parentElement; + const parent = pre.parentElement; + if (parent.hasClass(hasButtonClass)) { + parent.removeClass(hasButtonClass); + } + }); + document.querySelectorAll("." + runButtonClass).forEach((button) => button.remove()); + document.querySelectorAll("." + runButtonDisabledClass).forEach((button) => button.remove()); + document.querySelectorAll(".clear-button").forEach((button) => button.remove()); + document.querySelectorAll(".language-output").forEach((out) => out.remove()); + for (const executor of this.executors) { + executor.stop().then((_) => { + }); + } + console.log("Unloaded plugin: Execute Code"); + } + loadSettings() { + return __async(this, null, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + if (process.platform !== "win32") { + this.settings.wslMode = false; + } + }); + } + saveSettings() { + return __async(this, null, function* () { + yield this.saveData(this.settings); + }); + } + iterateOpenFilesAndAddRunButtons() { + this.app.workspace.iterateRootLeaves((leaf) => { + if (leaf.view instanceof import_obsidian44.FileView) { + this.addRunButtons(leaf.view.contentEl, leaf.view.file.path); + } + }); + } + addRunButtons(element, file) { + Array.from(element.getElementsByTagName("code")).forEach((codeBlock) => { + if (codeBlock.className.match(/^language-\{\w+/i)) { + codeBlock.className = codeBlock.className.replace(/^language-\{(\w+)/i, "language-$1 {"); + codeBlock.parentElement.className = codeBlock.className; + } + const language = codeBlock.className.toLowerCase(); + if (!language || !language.contains("language-")) + return; + const pre = codeBlock.parentElement; + const parent = pre.parentElement; + const srcCode = codeBlock.getText(); + let sanitizedClassList = this.sanitizeClassListOfCodeBlock(codeBlock); + const canonicalLanguage = getLanguageAlias( + supportedLanguages.find((lang) => sanitizedClassList.contains(`language-${lang}`)) + ); + if (canonicalLanguage && !parent.classList.contains(hasButtonClass)) { + const out = new Outputter(codeBlock, this.settings.allowInput); + parent.classList.add(hasButtonClass); + const button = this.createRunButton(); + pre.appendChild(button); + this.addListenerToButton(canonicalLanguage, srcCode, button, out, file); + } + }); + } + sanitizeClassListOfCodeBlock(codeBlock) { + let sanitizedClassList = Array.from(codeBlock.classList); + return sanitizedClassList.map((c) => c.toLowerCase()); + } + addListenerToButton(language, srcCode, button, out, file) { + if (language === "js") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + let transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + transformedCode = addMagicToJS(transformedCode); + this.runCode(transformedCode, out, button, this.settings.nodePath, this.settings.nodeArgs, this.settings.jsFileExtension, language, file); + })); + } else if (language === "java") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCode(transformedCode, out, button, this.settings.javaPath, this.settings.javaArgs, this.settings.javaFileExtension, language, file); + })); + } else if (language === "python") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + let transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + if (this.settings.pythonEmbedPlots) + transformedCode = addInlinePlotsToPython(transformedCode, TOGGLE_HTML_SIGIL); + transformedCode = addMagicToPython(transformedCode); + this.runCode(transformedCode, out, button, this.settings.pythonPath, this.settings.pythonArgs, this.settings.pythonFileExtension, language, file); + })); + } else if (language === "shell") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.shellPath, this.settings.shellArgs, this.settings.shellFileExtension, language, file); + })); + } else if (language === "batch") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.batchPath, this.settings.batchArgs, this.settings.batchFileExtension, language, file); + })); + } else if (language === "powershell") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.powershellPath, this.settings.powershellArgs, this.settings.powershellFileExtension, language, file); + })); + } else if (language === "cpp") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCode(transformedCode, out, button, this.settings.clingPath, `-std=${this.settings.clingStd} ${this.settings.clingArgs}`, this.settings.cppFileExtension, language, file); + })); + } else if (language === "prolog") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCode(transformedCode, out, button, "", "", "", language, file); + button.className = runButtonClass; + })); + } else if (language === "groovy") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.groovyPath, this.settings.groovyArgs, this.settings.groovyFileExtension, language, file); + })); + } else if (language === "rust") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCode(transformedCode, out, button, this.settings.cargoPath, "eval" + this.settings.cargoEvalArgs, this.settings.rustFileExtension, language, file); + })); + } else if (language === "r") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + let transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + transformedCode = addInlinePlotsToR(transformedCode); + this.runCode(transformedCode, out, button, this.settings.RPath, this.settings.RArgs, this.settings.RFileExtension, language, file); + })); + } else if (language === "go") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCode(transformedCode, out, button, this.settings.golangPath, this.settings.golangArgs, this.settings.golangFileExtension, language, file); + })); + } else if (language === "kotlin") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.kotlinPath, this.settings.kotlinArgs, this.settings.kotlinFileExtension, language, file); + })); + } else if (language === "ts") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.tsPath, this.settings.tsArgs, "ts", language, file); + })); + } else if (language === "lua") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.luaPath, this.settings.luaArgs, this.settings.luaFileExtension, language, file); + })); + } else if (language === "dart") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.dartPath, this.settings.dartArgs, this.settings.dartFileExtension, language, file); + })); + } else if (language === "cs") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.csPath, this.settings.csArgs, this.settings.csFileExtension, language, file); + })); + } else if (language === "haskell") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, "haskell").injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.useGhci ? this.settings.ghciPath : this.settings.runghcPath, this.settings.useGhci ? "" : "-f " + this.settings.ghcPath, "hs", language, file); + })); + } else if (language === "mathematica") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.mathematicaPath, this.settings.mathematicaArgs, this.settings.mathematicaFileExtension, language, file); + })); + } else if (language === "scala") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.scalaPath, this.settings.scalaArgs, this.settings.scalaFileExtension, language, file); + })); + } else if (language === "swift") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.swiftPath, this.settings.swiftArgs, this.settings.swiftFileExtension, language, file); + })); + } else if (language === "c") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.clingPath, this.settings.clingArgs, "c", language, file); + })); + } else if (language === "ruby") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.rubyPath, this.settings.rubyArgs, this.settings.rubyFileExtension, language, file); + })); + } else if (language === "sql") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.sqlPath, this.settings.sqlArgs, "sql", language, file); + })); + } else if (language === "octave") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + let transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + transformedCode = addInlinePlotsToOctave(transformedCode); + this.runCodeInShell(transformedCode, out, button, this.settings.octavePath, this.settings.octaveArgs, this.settings.octaveFileExtension, language, file); + })); + } else if (language === "maxima") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + let transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + transformedCode = addInlinePlotsToMaxima(transformedCode); + this.runCodeInShell(transformedCode, out, button, this.settings.maximaPath, this.settings.maximaArgs, this.settings.maximaFileExtension, language, file); + })); + } else if (language === "racket") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.racketPath, this.settings.racketArgs, this.settings.racketFileExtension, language, file); + })); + } else if (language === "applescript") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.applescriptPath, this.settings.applescriptArgs, this.settings.applescriptFileExtension, language, file); + })); + } else if (language === "zig") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.zigPath, this.settings.zigArgs, "zig", language, file); + })); + } else if (language === "ocaml") { + button.addEventListener("click", () => __async(this, null, function* () { + button.className = runButtonDisabledClass; + const transformedCode = yield new CodeInjector(this.app, this.settings, language).injectCode(srcCode); + this.runCodeInShell(transformedCode, out, button, this.settings.ocamlPath, this.settings.ocamlArgs, "ocaml", language, file); + })); + } + } + createRunButton() { + console.debug("Add run button"); + const button = document.createElement("button"); + button.classList.add(runButtonClass); + button.setText(buttonText); + return button; + } + runCode(codeBlockContent, outputter, button, cmd, cmdArgs, ext, language, file) { + outputter.startBlock(); + const executor = this.executors.getExecutorFor(file, language, false); + executor.run(codeBlockContent, outputter, cmd, cmdArgs, ext).then(() => { + button.className = runButtonClass; + outputter.closeInput(); + outputter.finishBlock(); + }); + } + runCodeInShell(codeBlockContent, outputter, button, cmd, cmdArgs, ext, language, file) { + const executor = this.executors.getExecutorFor(file, language, true); + executor.run(codeBlockContent, outputter, cmd, cmdArgs, ext).then(() => { + button.className = runButtonClass; + }); + } +}; diff --git a/.obsidian/plugins/execute-code/manifest.json b/.obsidian/plugins/execute-code/manifest.json new file mode 100644 index 0000000..5cd3db7 --- /dev/null +++ b/.obsidian/plugins/execute-code/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "execute-code", + "name": "Execute Code", + "version": "1.12.0", + "minAppVersion": "1.2.8", + "description": "Allows to execute code snippets within a note. Supported programming languages: C, CPP, Dart, Golang, Groovy, Kotlin, Java, JavaScript, TypeScript, Lean, Lua, CSharp, Prolog, Rust, Python, R, Ruby, Wolfram Mathematica, Haskell, Scala, Racket, F#, Batch, Shell & Powershell.", + "author": "twibiral", + "authorUrl": "https://www.github.com/twibiral", + "isDesktopOnly": true +} \ No newline at end of file diff --git a/.obsidian/plugins/execute-code/styles.css b/.obsidian/plugins/execute-code/styles.css new file mode 100644 index 0000000..ff165a8 --- /dev/null +++ b/.obsidian/plugins/execute-code/styles.css @@ -0,0 +1,218 @@ +/* @settings + +name: Execute Code Settings +id: obsidian-execute-code +settings: + - + id: color-section-title + title: Color Settings + type: heading + level: 3 + - + id: use-custom-output-color + title: Custom Code Output Color + description: Use a custom color for the output of code blocks + type: class-toggle + default: false + - + id: code-output-text-color + title: Output Text Color + type: variable-color + format: hex + opacity: false + default: '#FFFFFF' + - + id: use-custom-error-color + title: Custom Code Error Color + description: Use a custom color for the error output of code blocks + type: class-toggle + default: false + - + id: code-error-text-color + title: Error Text Color + type: variable-color + format: hex + opacity: false + default: '#FF0000' +*/ + +button.run-code-button { + display: none; + color: var(--text-muted); + position: absolute; + bottom: 0; + right: 0; + margin: 5px; + padding: 5px 20px 5px 20px; + z-index: 100; +} + +button.clear-button { + display: none; + color: var(--text-muted); + position: absolute; + bottom: 0; + left: 0; + margin: 5px; + padding: 5px 20px 5px 20px; + z-index: 100; +} + +pre:hover .run-code-button, pre:hover .clear-button { + display: block; +} + +pre:hover .run-button-disabled, pre:hover .clear-button-disabled { + display: none; +} + +.run-button-disabled, .clear-button-disabled { + display: none; +} + +pre:hover code.language-output { + margin-bottom: 28px; +} + +:not(.use-custom-output-color) code.language-output span.stdout { + color: var(--text-muted) !important; +} + +.use-custom-output-color code.language-output span.stdout { + color: var(--code-output-text-color) !important; +} + +:not(.use-custom-error-color) code.language-output span.stderr { + color: red !important; +} + +.use-custom-error-color code.language-output span.stderr { + color: var(--code-error-text-color) !important; +} + +code.language-output hr { + margin: 0 0 1em; +} + +.settings-code-input-box textarea, .settings-code-input-box input { + min-width: 400px; + min-height: 100px; + font-family: monospace; + resize: vertical; +} + +input.interactive-stdin { + font: inherit; +} + +.manage-executors-view h3 { + margin: 1em; +} + +.manage-executors-view ul { + margin: 1em; + padding: 0; + list-style-type: none; +} + +.manage-executors-view ul li { + padding: 0.5em; + background: var(--background-primary-alt); + border-radius: 4px; + display: grid; + flex-direction: column; + margin-bottom: 0.5em; +} + +.manage-executors-view small { + text-transform: uppercase; + font-weight: bold; + letter-spacing: 0.1ch; + grid-row: 1; +} + +.manage-executors-view .filename { + grid-row: 2; +} + +.manage-executors-view li button { + grid-column: 2; + grid-row: 1 / 3; + margin: 0; + padding: 0.25em; + display: flex; + align-items: center; + justify-content: center; + color: var(--text-muted); + background: none; +} + +.manage-executors-view li button:hover { + background: var(--background-tertiary); + color: var(--icon-color-hover); +} + +.manage-executors-view > div { + position: relative; +} + +.manage-executors-view .empty-state { + color: var(--text-muted); + padding: 0.5em; +} + +.has-run-code-button { + position: relative; +} + +.has-run-code-button pre { + z-index: 1; +} + +.load-state-indicator { + position: absolute; + top: 0.1em; + left: -2em; + width: 2em; + height: 2em; + background: var(--background-primary-alt); + border-top-left-radius: 4px; + border-bottom-left-radius: 4px; + color: var(--tx1); + transform: translateX(2em); + transition: transform 0.25s, opacity 0.25s; + opacity: 0; + pointer-events: none; + cursor: pointer; +} + +.load-state-indicator svg { + width: 1.5em; + height: 1.5em; + margin: 0.25em; +} + +.load-state-indicator.visible { + transform: translateX(0); + transform: translateX(var(--folding-offset, 0)); + opacity: 1; + pointer-events: all; +} + +.load-state-indicator::before { + content: ""; + box-shadow: -1em 0 1em -0.75em inset var(--background-modifier-box-shadow); + position: absolute; + display: block; + width: 100%; + height: 100%; + transform: translateX(-2em); + opacity: 0; + transition: transform 0.25s, opacity 0.25s; + pointer-events: none; +} + +.load-state-indicator.visible::before { + transform: translateX(0); + opacity: 1; +} diff --git a/.obsidian/plugins/obsidian-excalidraw-plugin/data.json b/.obsidian/plugins/obsidian-excalidraw-plugin/data.json new file mode 100644 index 0000000..7443d53 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw-plugin/data.json @@ -0,0 +1,799 @@ +{ + "folder": "Excalidraw", + "cropFolder": "", + "annotateFolder": "", + "embedUseExcalidrawFolder": false, + "templateFilePath": "Excalidraw/Template.excalidraw", + "scriptFolderPath": "Excalidraw/Scripts", + "fontAssetsPath": "Excalidraw/CJK Fonts", + "loadChineseFonts": false, + "loadJapaneseFonts": false, + "loadKoreanFonts": false, + "compress": true, + "decompressForMDView": false, + "onceOffCompressFlagReset": true, + "onceOffGPTVersionReset": true, + "autosave": true, + "autosaveIntervalDesktop": 60000, + "autosaveIntervalMobile": 30000, + "drawingFilenamePrefix": "Drawing ", + "drawingEmbedPrefixWithFilename": true, + "drawingFilnameEmbedPostfix": " ", + "drawingFilenameDateTime": "YYYY-MM-DD HH.mm.ss", + "useExcalidrawExtension": true, + "cropPrefix": "cropped_", + "annotatePrefix": "annotated_", + "annotatePreserveSize": false, + "previewImageType": "SVGIMG", + "renderingConcurrency": 3, + "allowImageCache": true, + "allowImageCacheInScene": true, + "displayExportedImageIfAvailable": false, + "previewMatchObsidianTheme": false, + "width": "400", + "height": "", + "overrideObsidianFontSize": false, + "dynamicStyling": "colorful", + "isLeftHanded": false, + "iframeMatchExcalidrawTheme": true, + "matchTheme": false, + "matchThemeAlways": false, + "matchThemeTrigger": false, + "defaultMode": "normal", + "defaultPenMode": "never", + "penModeDoubleTapEraser": true, + "penModeSingleFingerPanning": true, + "penModeCrosshairVisible": true, + "renderImageInMarkdownReadingMode": false, + "renderImageInHoverPreviewForMDNotes": false, + "renderImageInMarkdownToPDF": false, + "allowPinchZoom": false, + "allowWheelZoom": false, + "zoomToFitOnOpen": true, + "zoomToFitOnResize": true, + "zoomToFitMaxLevel": 2, + "linkPrefix": "📍", + "urlPrefix": "🌐", + "parseTODO": false, + "todo": "☐", + "done": "🗹", + "hoverPreviewWithoutCTRL": false, + "linkOpacity": 1, + "openInAdjacentPane": true, + "showSecondOrderLinks": true, + "focusOnFileTab": true, + "openInMainWorkspace": true, + "showLinkBrackets": true, + "allowCtrlClick": true, + "forceWrap": false, + "pageTransclusionCharLimit": 200, + "wordWrappingDefault": 0, + "removeTransclusionQuoteSigns": true, + "iframelyAllowed": true, + "pngExportScale": 1, + "exportWithTheme": true, + "exportWithBackground": true, + "exportPaddingSVG": 10, + "exportEmbedScene": false, + "keepInSync": false, + "autoexportSVG": false, + "autoexportPNG": false, + "autoExportLightAndDark": false, + "autoexportExcalidraw": false, + "embedType": "excalidraw", + "embedMarkdownCommentLinks": true, + "embedWikiLink": true, + "syncExcalidraw": false, + "experimentalFileType": false, + "experimentalFileTag": "✏️", + "experimentalLivePreview": true, + "fadeOutExcalidrawMarkup": false, + "loadPropertySuggestions": true, + "experimentalEnableFourthFont": false, + "experimantalFourthFont": "Virgil", + "addDummyTextElement": false, + "zoteroCompatibility": false, + "fieldSuggester": true, + "compatibilityMode": false, + "drawingOpenCount": 0, + "library": "deprecated", + "library2": { + "type": "excalidrawlib", + "version": 2, + "source": "https://github.com/zsviczian/obsidian-excalidraw-plugin/releases/tag/2.8.3", + "libraryItems": [] + }, + "imageElementNotice": true, + "mdSVGwidth": 500, + "mdSVGmaxHeight": 800, + "mdFont": "Virgil", + "mdFontColor": "Black", + "mdBorderColor": "Black", + "mdCSS": "", + "scriptEngineSettings": {}, + "defaultTrayMode": true, + "previousRelease": "2.8.3", + "showReleaseNotes": true, + "showNewVersionNotification": true, + "latexBoilerplate": "\\color{blue}", + "latexPreambleLocation": "preamble.sty", + "taskboneEnabled": false, + "taskboneAPIkey": "", + "pinnedScripts": [], + "customPens": [ + { + "type": "default", + "freedrawOnly": false, + "strokeColor": "#000000", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0, + "roughness": 0, + "penOptions": { + "highlighter": false, + "constantPressure": false, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "thinning": 0.6, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "easeOutSine", + "start": { + "cap": true, + "taper": 0, + "easing": "linear" + }, + "end": { + "cap": true, + "taper": 0, + "easing": "linear" + } + } + } + }, + { + "type": "highlighter", + "freedrawOnly": true, + "strokeColor": "#FFC47C", + "backgroundColor": "#FFC47C", + "fillStyle": "solid", + "strokeWidth": 2, + "roughness": null, + "penOptions": { + "highlighter": true, + "constantPressure": true, + "hasOutline": true, + "outlineWidth": 4, + "options": { + "thinning": 1, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "linear", + "start": { + "taper": 0, + "cap": true, + "easing": "linear" + }, + "end": { + "taper": 0, + "cap": true, + "easing": "linear" + } + } + } + }, + { + "type": "finetip", + "freedrawOnly": false, + "strokeColor": "#3E6F8D", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0.5, + "roughness": 0, + "penOptions": { + "highlighter": false, + "hasOutline": false, + "outlineWidth": 1, + "constantPressure": true, + "options": { + "smoothing": 0.4, + "thinning": -0.5, + "streamline": 0.4, + "easing": "linear", + "start": { + "taper": 5, + "cap": false, + "easing": "linear" + }, + "end": { + "taper": 5, + "cap": false, + "easing": "linear" + } + } + } + }, + { + "type": "fountain", + "freedrawOnly": false, + "strokeColor": "#000000", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 2, + "roughness": 0, + "penOptions": { + "highlighter": false, + "constantPressure": false, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "smoothing": 0.2, + "thinning": 0.6, + "streamline": 0.2, + "easing": "easeInOutSine", + "start": { + "taper": 150, + "cap": true, + "easing": "linear" + }, + "end": { + "taper": 1, + "cap": true, + "easing": "linear" + } + } + } + }, + { + "type": "marker", + "freedrawOnly": true, + "strokeColor": "#B83E3E", + "backgroundColor": "#FF7C7C", + "fillStyle": "dashed", + "strokeWidth": 2, + "roughness": 3, + "penOptions": { + "highlighter": false, + "constantPressure": true, + "hasOutline": true, + "outlineWidth": 4, + "options": { + "thinning": 1, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "linear", + "start": { + "taper": 0, + "cap": true, + "easing": "linear" + }, + "end": { + "taper": 0, + "cap": true, + "easing": "linear" + } + } + } + }, + { + "type": "thick-thin", + "freedrawOnly": true, + "strokeColor": "#CECDCC", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0, + "roughness": null, + "penOptions": { + "highlighter": true, + "constantPressure": true, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "thinning": 1, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "linear", + "start": { + "taper": 0, + "cap": true, + "easing": "linear" + }, + "end": { + "cap": true, + "taper": true, + "easing": "linear" + } + } + } + }, + { + "type": "thin-thick-thin", + "freedrawOnly": true, + "strokeColor": "#CECDCC", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0, + "roughness": null, + "penOptions": { + "highlighter": true, + "constantPressure": true, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "thinning": 1, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "linear", + "start": { + "cap": true, + "taper": true, + "easing": "linear" + }, + "end": { + "cap": true, + "taper": true, + "easing": "linear" + } + } + } + }, + { + "type": "default", + "freedrawOnly": false, + "strokeColor": "#000000", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0, + "roughness": 0, + "penOptions": { + "highlighter": false, + "constantPressure": false, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "thinning": 0.6, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "easeOutSine", + "start": { + "cap": true, + "taper": 0, + "easing": "linear" + }, + "end": { + "cap": true, + "taper": 0, + "easing": "linear" + } + } + } + }, + { + "type": "default", + "freedrawOnly": false, + "strokeColor": "#000000", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0, + "roughness": 0, + "penOptions": { + "highlighter": false, + "constantPressure": false, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "thinning": 0.6, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "easeOutSine", + "start": { + "cap": true, + "taper": 0, + "easing": "linear" + }, + "end": { + "cap": true, + "taper": 0, + "easing": "linear" + } + } + } + }, + { + "type": "default", + "freedrawOnly": false, + "strokeColor": "#000000", + "backgroundColor": "transparent", + "fillStyle": "hachure", + "strokeWidth": 0, + "roughness": 0, + "penOptions": { + "highlighter": false, + "constantPressure": false, + "hasOutline": false, + "outlineWidth": 1, + "options": { + "thinning": 0.6, + "smoothing": 0.5, + "streamline": 0.5, + "easing": "easeOutSine", + "start": { + "cap": true, + "taper": 0, + "easing": "linear" + }, + "end": { + "cap": true, + "taper": 0, + "easing": "linear" + } + } + } + } + ], + "numberOfCustomPens": 0, + "pdfScale": 4, + "pdfBorderBox": true, + "pdfFrame": false, + "pdfGapSize": 20, + "pdfGroupPages": false, + "pdfLockAfterImport": true, + "pdfNumColumns": 1, + "pdfNumRows": 1, + "pdfDirection": "right", + "pdfImportScale": 0.3, + "gridSettings": { + "DYNAMIC_COLOR": true, + "COLOR": "#000000", + "OPACITY": 50 + }, + "laserSettings": { + "DECAY_LENGTH": 50, + "DECAY_TIME": 1000, + "COLOR": "#ff0000" + }, + "embeddableMarkdownDefaults": { + "useObsidianDefaults": false, + "backgroundMatchCanvas": false, + "backgroundMatchElement": true, + "backgroundColor": "#fff", + "backgroundOpacity": 60, + "borderMatchElement": true, + "borderColor": "#fff", + "borderOpacity": 0, + "filenameVisible": false + }, + "markdownNodeOneClickEditing": false, + "canvasImmersiveEmbed": true, + "startupScriptPath": "", + "openAIAPIToken": "", + "openAIDefaultTextModel": "gpt-3.5-turbo-1106", + "openAIDefaultVisionModel": "gpt-4o", + "openAIDefaultImageGenerationModel": "dall-e-3", + "openAIURL": "https://api.openai.com/v1/chat/completions", + "openAIImageGenerationURL": "https://api.openai.com/v1/images/generations", + "openAIImageEditsURL": "https://api.openai.com/v1/images/edits", + "openAIImageVariationURL": "https://api.openai.com/v1/images/variations", + "modifierKeyConfig": { + "Mac": { + "LocalFileDragAction": { + "defaultAction": "image-import", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-import" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": true, + "meta_ctrl": false, + "result": "link" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-url" + }, + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": true, + "meta_ctrl": false, + "result": "embeddable" + } + ] + }, + "WebBrowserDragAction": { + "defaultAction": "image-url", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-url" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": true, + "meta_ctrl": false, + "result": "link" + }, + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": true, + "meta_ctrl": false, + "result": "embeddable" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-import" + } + ] + }, + "InternalDragAction": { + "defaultAction": "link", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "link" + }, + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": true, + "result": "embeddable" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": true, + "result": "image-fullsize" + } + ] + }, + "LinkClickAction": { + "defaultAction": "new-tab", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "active-pane" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "new-tab" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": true, + "meta_ctrl": false, + "result": "new-pane" + }, + { + "shift": true, + "ctrl_cmd": true, + "alt_opt": true, + "meta_ctrl": false, + "result": "popout-window" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": true, + "result": "md-properties" + } + ] + } + }, + "Win": { + "LocalFileDragAction": { + "defaultAction": "image-import", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-import" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "link" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-url" + }, + { + "shift": true, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "embeddable" + } + ] + }, + "WebBrowserDragAction": { + "defaultAction": "image-url", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-url" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "link" + }, + { + "shift": true, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "embeddable" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image-import" + } + ] + }, + "InternalDragAction": { + "defaultAction": "link", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "link" + }, + { + "shift": true, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "embeddable" + }, + { + "shift": true, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "image" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": true, + "meta_ctrl": false, + "result": "image-fullsize" + } + ] + }, + "LinkClickAction": { + "defaultAction": "new-tab", + "rules": [ + { + "shift": false, + "ctrl_cmd": false, + "alt_opt": false, + "meta_ctrl": false, + "result": "active-pane" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": false, + "result": "new-tab" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": true, + "meta_ctrl": false, + "result": "new-pane" + }, + { + "shift": true, + "ctrl_cmd": true, + "alt_opt": true, + "meta_ctrl": false, + "result": "popout-window" + }, + { + "shift": false, + "ctrl_cmd": true, + "alt_opt": false, + "meta_ctrl": true, + "result": "md-properties" + } + ] + } + } + }, + "slidingPanesSupport": false, + "areaZoomLimit": 1, + "longPressDesktop": 500, + "longPressMobile": 500, + "doubleClickLinkOpenViewMode": true, + "isDebugMode": false, + "rank": "Bronze", + "modifierKeyOverrides": [ + { + "modifiers": [ + "Mod" + ], + "key": "Enter" + }, + { + "modifiers": [ + "Mod" + ], + "key": "k" + }, + { + "modifiers": [ + "Mod" + ], + "key": "G" + } + ], + "showSplashscreen": true, + "pdfSettings": { + "pageSize": "A4", + "pageOrientation": "portrait", + "fitToPage": 1, + "paperColor": "white", + "customPaperColor": "#ffffff", + "alignment": "center", + "margin": "normal" + } +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-excalidraw-plugin/main.js b/.obsidian/plugins/obsidian-excalidraw-plugin/main.js new file mode 100644 index 0000000..5674a51 --- /dev/null +++ b/.obsidian/plugins/obsidian-excalidraw-plugin/main.js @@ -0,0 +1,10 @@ +"use strict";var obsidian_module=require("obsidian"),state=require("@codemirror/state"),view=require("@codemirror/view");const INITIAL_TIMESTAMP=Date.now();var LZString=function(){var r=String.fromCharCode,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$",e={};function t(r,o){if(!e[r]){e[r]={};for(var n=0;n>>8,n[2*e+1]=s%256}return n},decompressFromUint8Array:function(o){if(null==o)return i.decompress(o);for(var n=new Array(o.length/2),e=0,t=n.length;e>=1}else{for(t=1,e=0;e>=1}0==--l&&(l=Math.pow(2,h),h++),delete u[c]}else for(t=s[c],e=0;e>=1;0==--l&&(l=Math.pow(2,h),h++),s[p]=f++,c=String(a)}if(""!==c){if(Object.prototype.hasOwnProperty.call(u,c)){if(c.charCodeAt(0)<256){for(e=0;e>=1}else{for(t=1,e=0;e>=1}0==--l&&(l=Math.pow(2,h),h++),delete u[c]}else for(t=s[c],e=0;e>=1;0==--l&&(l=Math.pow(2,h),h++)}for(t=2,e=0;e>=1;for(;;){if(m<<=1,v==o-1){d.push(n(m));break}v++}return d.join("")},decompress:function(r){return null==r?"":""==r?null:i._decompress(r.length,32768,function(o){return r.charCodeAt(o)})},_decompress:function(o,n,e){var t,i,s,u,a,p,c,l=[],f=4,h=4,d=3,m="",v=[],g={val:e(0),position:n,index:1};for(t=0;t<3;t+=1)l[t]=t;for(s=0,a=Math.pow(2,2),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;switch(s){case 0:for(s=0,a=Math.pow(2,8),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;c=r(s);break;case 1:for(s=0,a=Math.pow(2,16),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;c=r(s);break;case 2:return""}for(l[3]=c,i=c,v.push(c);;){if(g.index>o)return"";for(s=0,a=Math.pow(2,d),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;switch(c=s){case 0:for(s=0,a=Math.pow(2,8),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;l[h++]=r(s),c=h-1,f--;break;case 1:for(s=0,a=Math.pow(2,16),p=1;p!=a;)u=g.val&g.position,g.position>>=1,0==g.position&&(g.position=n,g.val=e(g.index++)),s|=(u>0?1:0)*p,p<<=1;l[h++]=r(s),c=h-1,f--;break;case 2:return v.join("")}if(0==f&&(f=Math.pow(2,d),d++),l[c])m=l[c];else{if(c!==h)return null;m=i+i.charAt(0)}v.push(m),l[h++]=i+m.charAt(0),i=m,0==--f&&(f=Math.pow(2,d),d++)}}};return i}();"function"==typeof define&&define.amd?define(function(){return LZString}):"undefined"!=typeof module&&null!=module?module.exports=LZString:"undefined"!=typeof angular&&null!=angular&&angular.module("LZString",[]).factory("LZString",function(){return LZString}); +let REACT_PACKAGES = `!function(){var e,t;e=this,t=function(e){function M(e){return null!==e&&"object"==typeof e&&"function"==typeof(e=te&&e[te]||e["@@iterator"])?e:null}function t(e,t,n){this.props=e,this.context=t,this.refs=oe,this.updater=n||ne}function n(){}function r(e,t,n){this.props=e,this.context=t,this.refs=oe,this.updater=n||ne}function o(e,t,n){var r,o={},u=null,a=null;if(null!=t)for(r in void 0!==t.ref&&(a=t.ref),void 0!==t.key&&(u=""+t.key),t)ae.call(t,r)&&!ie.hasOwnProperty(r)&&(o[r]=t[r]);var i=arguments.length-2;if(1===i)o.children=n;else if(1>>1,o=e[r];if(!(0>>1;rt)||e&&!q());){var r,o=R.callback;"function"==typeof o?(R.callback=null,P=R.priorityLevel,r=o(R.expirationTime<=t),t=v(),"function"==typeof r?R.callback=r:R===i(C)&&l(C),y(t)):l(C),R=i(C)}var u,a=null!==R||(null!==(u=i(E))&&_(d,u.startTime-t),!1);return a}finally{R=null,P=n,$=!1}}function q(){return!(v()-de")?l.replace("",n.displayName):l}while(1<=u&&0<=i);break}}}finally{xo=!1,Error.prepareStackTrace=t}return(n=n?n.displayName||n.name:"")?Q(n):""}function $(e){switch(e.tag){case 5:return Q(e.type);case 16:return Q("Lazy");case 13:return Q("Suspense");case 19:return Q("SuspenseList");case 0:case 2:case 15:return e=j(e.type,!1);case 11:return e=j(e.type.render,!1);case 1:return e=j(e.type,!0);default:return""}}function q(e){if(null!=e){if("function"==typeof e)return e.displayName||e.name||null;if("string"==typeof e)return e;switch(e){case co:return"Fragment";case so:return"Portal";case po:return"Profiler";case fo:return"StrictMode";case yo:return"Suspense";case vo:return"SuspenseList"}if("object"==typeof e)switch(e.$$typeof){case ho:return(e.displayName||"Context")+".Consumer";case mo:return(e._context.displayName||"Context")+".Provider";case go:var n=e.render;return e=(e=e.displayName)?e:""!==(e=n.displayName||n.name||"")?"ForwardRef("+e+")":"ForwardRef";case bo:return null!==(n=e.displayName||null)?n:q(e.type)||"Memo";case ko:n=e._payload,e=e._init;try{return q(e(n))}catch(e){}}}return null}function K(e){var n=e.type;switch(e.tag){case 24:return"Cache";case 9:return(n.displayName||"Context")+".Consumer";case 10:return(n._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=(e=n.render).displayName||e.name||"",n.displayName||(""!==e?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return n;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return q(n);case 8:return n===fo?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if("function"==typeof n)return n.displayName||n.name||null;if("string"==typeof n)return n}return null}function Y(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":case"object":return e;default:return""}}function X(e){var n=e.type;return(e=e.nodeName)&&"input"===e.toLowerCase()&&("checkbox"===n||"radio"===n)}function G(e){var n,t,r=X(e)?"checked":"value",l=Object.getOwnPropertyDescriptor(e.constructor.prototype,r),a=""+e[r];if(!e.hasOwnProperty(r)&&void 0!==l&&"function"==typeof l.get&&"function"==typeof l.set)return n=l.get,t=l.set,Object.defineProperty(e,r,{configurable:!0,get:function(){return n.call(this)},set:function(e){a=""+e,t.call(this,e)}}),Object.defineProperty(e,r,{enumerable:l.enumerable}),{getValue:function(){return a},setValue:function(e){a=""+e},stopTracking:function(){e._valueTracker=null,delete e[r]}}}function Z(e){e._valueTracker||(e._valueTracker=G(e))}function J(e){var n,t,r;return!(!e||(n=e._valueTracker)&&(t=n.getValue(),r="",(e=r=e?X(e)?e.checked?"true":"false":e.value:r)===t||(n.setValue(e),0)))}function ee(n){if(void 0===(n=n||("undefined"!=typeof document?document:void 0)))return null;try{return n.activeElement||n.body}catch(e){return n.body}}function ne(e,n){var t=n.checked;return g({},n,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=t?t:e._wrapperState.initialChecked})}function te(e,n){var t=null==n.defaultValue?"":n.defaultValue,r=null!=n.checked?n.checked:n.defaultChecked,t=Y(null!=n.value?n.value:t);e._wrapperState={initialChecked:r,initialValue:t,controlled:"checkbox"===n.type||"radio"===n.type?null!=n.checked:null!=n.value}}function re(e,n){null!=(n=n.checked)&&B(e,"checked",n,!1)}function le(e,n){re(e,n);var t=Y(n.value),r=n.type;if(null!=t)"number"===r?(0===t&&""===e.value||e.value!=t)&&(e.value=""+t):e.value!==""+t&&(e.value=""+t);else if("submit"===r||"reset"===r)return void e.removeAttribute("value");n.hasOwnProperty("value")?oe(e,n.type,t):n.hasOwnProperty("defaultValue")&&oe(e,n.type,Y(n.defaultValue)),null==n.checked&&null!=n.defaultChecked&&(e.defaultChecked=!!n.defaultChecked)}function ae(e,n,t){if(n.hasOwnProperty("value")||n.hasOwnProperty("defaultValue")){var r=n.type;if(("submit"===r||"reset"===r)&&null==n.value)return;n=""+e._wrapperState.initialValue,t||n===e.value||(e.value=n),e.defaultValue=n}""!==(t=e.name)&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,""!==t&&(e.name=t)}function oe(e,n,t){"number"===n&&ee(e.ownerDocument)===e||(null==t?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+t&&(e.defaultValue=""+t))}function ue(e,n,t,r){if(e=e.options,n){n={};for(var l=0;l>>=0)?32:31-(iu(e)/su|0)|0}function Re(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return 4194240&e;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return 130023424&e;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function De(e,n){var t=e.pendingLanes;if(0===t)return 0;var r,l=0,a=e.suspendedLanes,o=e.pingedLanes,u=268435455&t;if(0!==u?0!==(r=u&~a)?l=Re(r):0!==(o&=u)&&(l=Re(o)):0!==(u=t&~a)?l=Re(u):0!==o&&(l=Re(o)),0===l)return 0;if(0!==n&&n!==l&&0==(n&a)&&((o=n&-n)<=(a=l&-l)||16===a&&0!=(4194240&o)))return n;if(0!=(4&l)&&(l|=16&t),0!==(n=e.entangledLanes))for(e=e.entanglements,n&=l;0>=r,a-=r,Xi=1<<32-uu(n)+a|t<u?(i=o,o=null):i=o.sibling;var s=y(n,o,t[u],r);if(null===s){null===o&&(o=i);break}f&&o&&null===s.alternate&&d(n,o),e=h(s,e,u),null===a?l=s:a.sibling=s,a=s,o=i}if(u===t.length)p(n,o);else if(null===o)for(;uu?(i=o,o=null):i=o.sibling;var c=y(n,o,s.value,r);if(null===c){null===o&&(o=i);break}f&&o&&null===c.alternate&&d(n,o),e=h(c,e,u),null===a?l=c:a.sibling=c,a=c,o=i}if(s.done)p(n,o);else if(null===o)for(;!s.done;u++,s=t.next())null!==(s=g(n,s.value,r))&&(e=h(s,e,u),null===a?l=s:a.sibling=s,a=s);else{for(o=m(n,o);!s.done;u++,s=t.next())null!==(s=v(o,n,u,s.value,r))&&(f&&null!==s.alternate&&o.delete(null===s.key?u:s.key),e=h(s,e,u),null===a?l=s:a.sibling=s,a=s);f&&o.forEach(function(e){return d(n,e)})}return E&&vt(n,u),l}function w(e,n,t,r){if("object"==typeof(t="object"==typeof t&&null!==t&&t.type===co&&null===t.key?t.props.children:t)&&null!==t){switch(t.$$typeof){case io:e:{for(var l=t.key,a=n;null!==a;){if(a.key===l){if((l=t.type)===co){if(7===a.tag){p(e,a.sibling),(n=o(a,t.props.children)).return=e,e=n;break e}}else if(a.elementType===l||"object"==typeof l&&null!==l&&l.$$typeof===ko&&Mt(l)===a.type){p(e,a.sibling),(n=o(a,t.props)).ref=Lt(e,a,t),n.return=e,e=n;break e}p(e,a);break}d(e,a),a=a.sibling}e=t.type===co?((n=za(t.props.children,e.mode,r,t.key)).return=e,n):((r=Na(t.type,t.key,t.props,null,e.mode,r)).ref=Lt(e,n,t),r.return=e,r)}return u(e);case so:e:{for(a=t.key;null!==n;){if(n.key===a){if(4===n.tag&&n.stateNode.containerInfo===t.containerInfo&&n.stateNode.implementation===t.implementation){p(e,n.sibling),(n=o(n,t.children||[])).return=e,e=n;break e}p(e,n);break}d(e,n),n=n.sibling}(n=La(t,e.mode,r)).return=e,e=n}return u(e);case ko:return w(e,n,(a=t._init)(t._payload),r)}if(Eo(t))return b(e,n,t,r);if(H(t))return k(e,n,t,r);Tt(e,t)}return"string"==typeof t&&""!==t||"number"==typeof t?(t=""+t,(n=null!==n&&6===n.tag?(p(e,n.sibling),o(n,t)):(p(e,n),_a(t,e.mode,r))).return=e,u(e=n)):p(e,n)}return w}function Rt(){os=as=ls=null}function Dt(e,n){n=rs.current,s(rs),e._currentValue=n}function Ot(e,n,t){for(;null!==e;){var r=e.alternate;if((e.childLanes&n)!==n?(e.childLanes|=n,null!==r&&(r.childLanes|=n)):null!==r&&(r.childLanes&n)!==n&&(r.childLanes|=n),e===t)break;e=e.return}}function It(e,n){(os=as=null)!==(e=(ls=e).dependencies)&&null!==e.firstContext&&(0!=(e.lanes&n)&&(_=!0),e.firstContext=null)}function Ut(e){var n=e._currentValue;if(os!==e)if(e={context:e,memoizedValue:n,next:null},null===as){if(null===ls)throw Error(S(308));as=e,ls.dependencies={lanes:0,firstContext:e}}else as=as.next=e;return n}function Vt(e){null===us?us=[e]:us.push(e)}function At(e,n,t,r){var l=n.interleaved;return null===l?(t.next=t,Vt(n)):(t.next=l.next,l.next=t),n.interleaved=t,Wt(e,r)}function Wt(e,n){e.lanes|=n;var t=e.alternate;for(null!==t&&(t.lanes|=n),e=(t=e).return;null!==e;)e.childLanes|=n,null!==(t=e.alternate)&&(t.childLanes|=n),e=(t=e).return;return 3===t.tag?t.stateNode:null}function Bt(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function Ht(e,n){e=e.updateQueue,n.updateQueue===e&&(n.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function Qt(e,n){return{eventTime:e,lane:n,tag:0,payload:null,callback:null,next:null}}function jt(e,n,t){var r,l=e.updateQueue;return null===l?null:(l=l.shared,(0!=(2&F)?(null===(r=l.pending)?n.next=n:(n.next=r.next,r.next=n),l.pending=n,is):(null===(r=l.interleaved)?(n.next=n,Vt(l)):(n.next=r.next,r.next=n),l.interleaved=n,Wt))(e,t))}function $t(e,n,t){var r;null!==(n=n.updateQueue)&&(n=n.shared,0!=(4194240&t))&&(r=n.lanes,r&=e.pendingLanes,He(e,n.lanes=t|=r))}function qt(e,n){var t=e.updateQueue,r=e.alternate;if(null!==r&&t===(r=r.updateQueue)){var l=null,a=null;if(null!==(t=t.firstBaseUpdate)){do{var o={eventTime:t.eventTime,lane:t.lane,tag:t.tag,payload:t.payload,callback:t.callback,next:null}}while(null===a?l=a=o:a=a.next=o,null!==(t=t.next));null===a?l=a=n:a=a.next=n}else l=a=n;t={baseState:r.baseState,firstBaseUpdate:l,lastBaseUpdate:a,shared:r.shared,effects:r.effects},e.updateQueue=t}else null===(e=t.lastBaseUpdate)?t.firstBaseUpdate=n:e.next=n,t.lastBaseUpdate=n}function Kt(e,n,t,r){var l,a,o=e.updateQueue,u=(ss=!1,o.firstBaseUpdate),i=o.lastBaseUpdate;if(null!==(f=o.shared.pending)&&(o.shared.pending=null,a=(l=f).next,(l.next=null)===i?u=a:i.next=a,i=l,null!==(c=e.alternate))&&(f=(c=c.updateQueue).lastBaseUpdate)!==i&&(null===f?c.firstBaseUpdate=a:f.next=a,c.lastBaseUpdate=l),null!==u){for(var s=o.baseState,i=0,c=a=l=null,f=u;;){var d=f.lane,p=f.eventTime;if((r&d)===d){null!==c&&(c=c.next={eventTime:p,lane:0,tag:f.tag,payload:f.payload,callback:f.callback,next:null});e:{var m=e,h=f,d=n,p=t;switch(h.tag){case 1:if("function"==typeof(m=h.payload)){s=m.call(p,s,d);break e}s=m;break e;case 3:m.flags=-65537&m.flags|128;case 0:if(null==(d="function"==typeof(m=h.payload)?m.call(p,s,d):m))break e;s=g({},s,d);break e;case 2:ss=!0}}null!==f.callback&&0!==f.lane&&(e.flags|=64,null===(d=o.effects)?o.effects=[f]:d.push(f))}else p={eventTime:p,lane:d,tag:f.tag,payload:f.payload,callback:f.callback,next:null},null===c?(a=c=p,l=s):c=c.next=p,i|=d;if(null===(f=f.next)){if(null===(f=o.shared.pending))break;f=(d=f).next,d.next=null,o.lastBaseUpdate=d,o.shared.pending=null}}if(null===c&&(l=s),o.baseState=l,o.firstBaseUpdate=a,o.lastBaseUpdate=c,null!==(n=o.shared.interleaved))for(o=n;i|=o.lane,(o=o.next)!==n;);else null===u&&(o.shared.lanes=0);Qs|=i,e.lanes=i,e.memoizedState=s}}function Yt(e,n,t){if(e=n.effects,(n.effects=null)!==e)for(n=0;n<\\/script>",e=e.removeChild(e.firstChild)):"string"==typeof r.is?e=o.createElement(t,{is:r.is}):(e=o.createElement(t),"select"===t&&(o=e,r.multiple?o.multiple=!0:r.size&&(o.size=r.size))):e=o.createElementNS(e,t),e[Li]=n,e[Ti]=r,Ls(e,n,!1,!1),n.stateNode=e;e:{switch(o=ye(t,r),t){case"dialog":c("cancel",e),c("close",e),a=r;break;case"iframe":case"object":case"embed":c("load",e),a=r;break;case"video":case"audio":for(a=0;aYs&&(n.flags|=128,wl(i,!(r=!0)),n.lanes=4194304)}else{if(!r)if(null!==(e=nr(o))){if(n.flags|=128,r=!0,null!==(t=e.updateQueue)&&(n.updateQueue=t,n.flags|=4),wl(i,!0),null===i.tail&&"hidden"===i.tailMode&&!o.alternate&&!E)return p(n),null}else 2*y()-i.renderingStartTime>Ys&&1073741824!==t&&(n.flags|=128,wl(i,!(r=!0)),n.lanes=4194304);i.isBackwards?(o.sibling=n.child,n.child=o):(null!==(t=i.last)?t.sibling=o:n.child=o,i.last=o)}if(null!==i.tail)return n=i.tail,i.rendering=n,i.tail=n.sibling,i.renderingStartTime=y(),n.sibling=null,t=C.current,f(C,r?1&t|2:1&t),n}return p(n),null;case 22:case 23:return O=Bs.current,s(Bs),r=null!==n.memoizedState,null!==e&&null!==e.memoizedState!==r&&(n.flags|=8192),r&&0!=(1&n.mode)?0!=(1073741824&O)&&(p(n),6&n.subtreeFlags)&&(n.flags|=8192):p(n),null;case 24:case 25:return null}throw Error(S(156,n.tag))}function xl(e,n,t){switch(wt(n),n.tag){case 1:return h(n.type)&&(s(b),s(v)),65536&(e=n.flags)?(n.flags=-65537&e|128,n):null;case 3:return Zt(),s(b),s(v),tr(),0!=(65536&(e=n.flags))&&0==(128&e)?(n.flags=-65537&e|128,n):null;case 5:return er(n),null;case 13:if(s(C),null!==(e=n.memoizedState)&&null!==e.dehydrated){if(null===n.alternate)throw Error(S(340));Pt()}return 65536&(e=n.flags)?(n.flags=-65537&e|128,n):null;case 19:return s(C),null;case 4:return Zt(),null;case 10:return Dt(n.type._context),null;case 22:case 23:return O=Bs.current,s(Bs),null;default:return null}}function El(n,t){var e=n.ref;if(null!==e)if("function"==typeof e)try{e(null)}catch(e){w(n,t,e)}else e.current=null}function Cl(n,t,e){try{e()}catch(e){w(n,t,e)}}function Nl(e,n){if(Ei=Su,Dn(e=Rn())){if("selectionStart"in e)var t={start:e.selectionStart,end:e.selectionEnd};else e:if((a=(t=(t=e.ownerDocument)&&t.defaultView||window).getSelection&&t.getSelection())&&0!==a.rangeCount){var t=a.anchorNode,r=a.anchorOffset,l=a.focusNode,a=a.focusOffset;try{t.nodeType,l.nodeType}catch(e){t=null;break e}var o,u=0,i=-1,s=-1,c=0,f=0,d=e,p=null;n:for(;;){for(;d!==t||0!==r&&3!==d.nodeType||(i=u+r),d!==l||0!==a&&3!==d.nodeType||(s=u+a),3===d.nodeType&&(u+=d.nodeValue.length),null!==(o=d.firstChild);)p=d,d=o;for(;;){if(d===e)break n;if(p===t&&++c===r&&(i=u),p===l&&++f===a&&(s=u),null!==(o=d.nextSibling))break;p=(d=p).parentNode}d=o}t=-1===i||-1===s?null:{start:i,end:s}}else t=null;t=t||{start:0,end:0}}else t=null;for(Su=!(Ci={focusedElem:e,selectionRange:t}),T=n;null!==T;)if(e=(n=T).child,0!=(1028&n.subtreeFlags)&&null!==e)e.return=n,T=e;else for(;null!==T;){n=T;try{var m,h,g,y,v=n.alternate;if(0!=(1024&n.flags))switch(n.tag){case 0:case 11:case 15:break;case 1:null!==v&&(m=v.memoizedProps,h=v.memoizedState,y=(g=n.stateNode).getSnapshotBeforeUpdate(n.elementType===n.type?m:Ar(n.type,m),h),g.__reactInternalSnapshotBeforeUpdate=y);break;case 3:var b=n.stateNode.containerInfo;1===b.nodeType?b.textContent="":9===b.nodeType&&b.documentElement&&b.removeChild(b.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(S(163))}}catch(e){w(n,n.return,e)}if(null!==(e=n.sibling)){e.return=n.return,T=e;break}T=n.return}return v=Os,Os=!1,v}function zl(e,n,t){var r=n.updateQueue;if(null!==(r=null!==r?r.lastEffect:null)){var l,a=r=r.next;do{}while((a.tag&e)===e&&(l=a.destroy,(a.destroy=void 0)!==l)&&Cl(n,t,l),(a=a.next)!==r)}}function Pl(e,n){if(null!==(n=null!==(n=n.updateQueue)?n.lastEffect:null)){var t,r=n=n.next;do{}while((r.tag&e)===e&&(t=r.create,r.destroy=t()),(r=r.next)!==n)}}function _l(e){var n,t=e.ref;null!==t&&(n=e.stateNode,e.tag,e=n,"function"==typeof t?t(e):t.current=e)}function Ll(e){var n=e.alternate;null!==n&&(e.alternate=null,Ll(n)),e.child=null,e.deletions=null,e.sibling=null,5===e.tag&&null!==(n=e.stateNode)&&(delete n[Li],delete n[Ti],delete n[Fi],delete n[Ri],delete n[Di]),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function Tl(e){return 5===e.tag||3===e.tag||4===e.tag}function Ml(e){e:for(;;){for(;null===e.sibling;){if(null===e.return||Tl(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;5!==e.tag&&6!==e.tag&&18!==e.tag;){if(2&e.flags)continue e;if(null===e.child||4===e.tag)continue e;e=(e.child.return=e).child}if(!(2&e.flags))return e.stateNode}}function Fl(e,n,t){var r=e.tag;if(5===r||6===r)e=e.stateNode,n?(8===t.nodeType?t.parentNode:t).insertBefore(e,n):(8===t.nodeType?(n=t.parentNode).insertBefore(e,t):(n=t).appendChild(e),null==(t=t._reactRootContainer)&&null===n.onclick&&(n.onclick=Jn));else if(4!==r&&null!==(e=e.child))for(Fl(e,n,t),e=e.sibling;null!==e;)Fl(e,n,t),e=e.sibling}function Rl(e,n,t){var r=e.tag;if(5===r||6===r)e=e.stateNode,n?t.insertBefore(e,n):t.appendChild(e);else if(4!==r&&null!==(e=e.child))for(Rl(e,n,t),e=e.sibling;null!==e;)Rl(e,n,t),e=e.sibling}function Dl(e,n,t){for(t=t.child;null!==t;)Ol(e,n,t),t=t.sibling}function Ol(e,n,t){if(ou&&"function"==typeof ou.onCommitFiberUnmount)try{ou.onCommitFiberUnmount(au,t)}catch(e){}switch(t.tag){case 5:L||El(t,n);case 6:var r=M,l=Is;M=null,Dl(e,n,t),Is=l,null!==(M=r)&&(Is?(e=M,t=t.stateNode,(8===e.nodeType?e.parentNode:e).removeChild(t)):M.removeChild(t.stateNode));break;case 18:null!==M&&(Is?(e=M,t=t.stateNode,8===e.nodeType?tt(e.parentNode,t):1===e.nodeType&&tt(e,t),Je(e)):tt(M,t.stateNode));break;case 4:r=M,l=Is,M=t.stateNode.containerInfo,Is=!0,Dl(e,n,t),M=r,Is=l;break;case 0:case 11:case 14:case 15:if(!L&&null!==(r=t.updateQueue)&&null!==(r=r.lastEffect)){l=r=r.next;do{var a=(o=l).destroy,o=o.tag}while(void 0===a||0==(2&o)&&0==(4&o)||Cl(t,n,a),(l=l.next)!==r)}Dl(e,n,t);break;case 1:if(!L&&(El(t,n),"function"==typeof(r=t.stateNode).componentWillUnmount))try{r.props=t.memoizedProps,r.state=t.memoizedState,r.componentWillUnmount()}catch(e){w(t,n,e)}Dl(e,n,t);break;case 21:Dl(e,n,t);break;case 22:1&t.mode?(L=(r=L)||null!==t.memoizedState,Dl(e,n,t),L=r):Dl(e,n,t);break;default:Dl(e,n,t)}}function Il(t){var r,e=t.updateQueue;null!==e&&((t.updateQueue=null)===(r=t.stateNode)&&(r=t.stateNode=new Ds),e.forEach(function(e){var n=ka.bind(null,t,e);r.has(e)||(r.add(e),e.then(n,n))}))}function Ul(e,n,t){if(null!==(t=n.deletions))for(var r=0;r