var __defProp = Object.defineProperty;
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __export = (target, all) => {
  __markAsModule(target);
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __accessCheck = (obj, member, msg) => {
  if (!member.has(obj))
    throw TypeError("Cannot " + msg);
};
var __privateGet = (obj, member, getter) => {
  __accessCheck(obj, member, "read from private field");
  return getter ? getter.call(obj) : member.get(obj);
};
var __privateAdd = (obj, member, value) => {
  if (member.has(obj))
    throw TypeError("Cannot add the same private member more than once");
  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};
var __privateSet = (obj, member, value, setter) => {
  __accessCheck(obj, member, "write to private field");
  setter ? setter.call(obj, value) : member.set(obj, value);
  return value;
};
var __privateMethod = (obj, member, method) => {
  __accessCheck(obj, member, "access private method");
  return method;
};
__export(exports, {
  Rewriter: () => Rewriter
});
var _ptr, _t, _init, init_fn, _ptr2, _wasm, _guard, guard_fn, _ptr3, _wasm2, _guard2, guard_fn2, _ptr4, _wasm3, _guard3, guard_fn3, _ptr5, _wasm4, _guard4, guard_fn4, _ptr6, _wasm5, _guard5, guard_fn5;
let wasm;
const rewriters = new Map();
const __c__ = Symbol("lhc");
const handlers = new WeakMap();
const callbacks = new WeakMap();
{
  const module2 = new WebAssembly.Module(require('fs').readFileSync(require('path').join(__dirname, '../../src/html/html.wasm')));
  const instance = new WebAssembly.Instance(module2, {
    io: { drop(id) {
      const x = rewriters.get(id);
      handlers.delete(x), callbacks.delete(x), rewriters.delete(id);
    } },
    env: {
      chunk(id, ptr) {
        callbacks.get(rewriters.get(id))(mem.u8(ptr, mem.length()).slice());
      },
      element(id, kind, index, ptr) {
        const r = rewriters.get(id);
        const h = handlers.get(r).on[index];
        try {
          if (kind === 0) {
            const text = new Text(ptr, wasm);
            h.text(text), text[__c__]();
          } else if (kind === 1) {
            const element = new Element(ptr, wasm);
            h.element(element), element[__c__]();
          } else if (kind === 2) {
            const comment = new Comment(ptr, wasm);
            h.comments(comment), comment[__c__]();
          }
        } catch (err) {
          return rewriters.get(id).error = err, 0;
        }
        return 1;
      },
      document(id, kind, index, ptr) {
        const r = rewriters.get(id);
        const h = handlers.get(r).document[index];
        try {
          if (kind === 0) {
            const end = new End(ptr, wasm);
            h.end(end), end[__c__]();
          } else if (kind === 2) {
            const text = new Text(ptr, wasm);
            h.text(text), text[__c__]();
          } else if (kind === 1) {
            const doctype = new Doctype(ptr, wasm);
            h.doctype(doctype), doctype[__c__]();
          } else if (kind === 3) {
            const comment = new Comment(ptr, wasm);
            h.comments(comment), comment[__c__]();
          }
        } catch (err) {
          return rewriters.get(id).error = err, 0;
        }
        return 1;
      }
    }
  });
  wasm = instance.exports;
}
class mem {
  static length() {
    return wasm.wlen();
  }
  static token() {
    return wasm.wtoken();
  }
  static alloc(size) {
    return wasm.walloc(size);
  }
  static free(ptr, size) {
    return wasm.wfree(ptr, size);
  }
  static u8(ptr, size) {
    return new Uint8Array(wasm.memory.buffer, ptr, size);
  }
  static u32(ptr, size) {
    return new Uint32Array(wasm.memory.buffer, ptr, size);
  }
  static gc(f) {
    return !("FinalizationRegistry" in globalThis) ? { delete(_) {
    }, add(_, __) {
    } } : { r: new FinalizationRegistry(f), delete(k) {
      this.r.unregister(k);
    }, add(k, v) {
      this.r.register(k, v, k);
    } };
  }
  static copy_and_free(ptr, size) {
    let slice = mem.u8(ptr, size).slice();
    return wasm.wfree(ptr, size), slice;
  }
}
const gc = mem.gc((ptr) => wasm.free(ptr));
const encode_utf8 = "Deno" in globalThis ? Deno.core.encode : (() => {
  const e = new TextEncoder();
  return (s) => e.encode(s);
})();
const decode_utf8 = "Deno" in globalThis ? Deno.core.decode : (() => {
  const d = new TextDecoder();
  return (b) => d.decode(b);
})();
class Rewriter {
  constructor(fn) {
    __privateAdd(this, _init);
    __privateAdd(this, _ptr, 0);
    __privateAdd(this, _t, null);
    callbacks.set(this, fn);
    handlers.set(this, { on: [], document: [] });
  }
  drop() {
    gc.delete(this);
    __privateSet(this, _ptr, wasm.free(__privateGet(this, _ptr)));
  }
  end() {
    if (__privateGet(this, _ptr) === 0)
      __privateMethod(this, _init, init_fn).call(this);
    else if (__privateGet(this, _ptr) == null)
      return;
    const c = wasm.end(__privateGet(this, _ptr));
    gc.delete(this);
    __privateSet(this, _ptr, null);
    if (c === 3)
      throw this.error;
    if (c === 2)
      throw new Error("html: memory limit has been exceeded");
    if (c === 1)
      throw new Error("html: parser has encountered a text content tag in the context where it is ambiguous whether this tag should be ignored or not");
  }
  write(chunk) {
    if (__privateGet(this, _ptr) === 0)
      __privateMethod(this, _init, init_fn).call(this);
    else if (__privateGet(this, _ptr) == null)
      throw new Error("html: rewriter is ended");
    if (typeof chunk === "string")
      chunk = encode_utf8(chunk);
    const ptr = mem.alloc(chunk.length);
    mem.u8(ptr, chunk.length).set(chunk);
    const c = wasm.write(__privateGet(this, _ptr), ptr, chunk.length);
    if (c === 3)
      throw this.drop(), this.error;
    if (c === 2)
      throw this.drop(), new Error("html: memory limit has been exceeded");
    if (c === 1)
      throw this.drop(), new Error("html: parser has encountered a text content tag in the context where it is ambiguous whether this tag should be ignored or not");
  }
  on(selector, handler) {
    if (__privateGet(this, _ptr) !== 0)
      throw new Error("html: cannot add handler after writing");
    const buf = encode_utf8(selector);
    const ptr = mem.alloc(buf.length);
    mem.u8(ptr, buf.length).set(buf);
    const c = wasm.validate_selector(ptr, buf.length);
    if (c !== 0)
      throw new SyntaxError(`html: ${decode_utf8(mem.u8(c, mem.length()))}`);
    const h = handlers.get(this).on;
    h.push(handler);
    const meta = handler.meta = [];
    if ("text" in handler)
      meta.push({ kind: 0, name: selector, index: h.length - 1 });
    if ("element" in handler)
      meta.push({ kind: 1, name: selector, index: h.length - 1 });
    if ("comments" in handler)
      meta.push({ kind: 2, name: selector, index: h.length - 1 });
  }
  onDocument(handler) {
    if (__privateGet(this, _ptr) !== 0)
      throw new Error("html: cannot add handler after writing");
    const h = handlers.get(this).document;
    h.push(handler);
    const meta = handler.meta = [];
    if ("end" in handler)
      meta.push({ kind: 0, index: h.length - 1 });
    if ("text" in handler)
      meta.push({ kind: 2, index: h.length - 1 });
    if ("doctype" in handler)
      meta.push({ kind: 1, index: h.length - 1 });
    if ("comments" in handler)
      meta.push({ kind: 3, index: h.length - 1 });
  }
}
_ptr = new WeakMap();
_t = new WeakMap();
_init = new WeakSet();
init_fn = function() {
  const h = handlers.get(this);
  rewriters.set(__privateSet(this, _t, mem.token()), this);
  const json = encode_utf8(JSON.stringify({
    strict: true,
    element_handlers: h.on.map((x) => x.meta).flat(),
    document_handlers: h.document.map((x) => x.meta).flat()
  }));
  const ptr = mem.alloc(json.length);
  mem.u8(ptr, json.length).set(json);
  gc.add(this, __privateSet(this, _ptr, wasm.new(__privateGet(this, _t), callbacks.get(this) ? 1 : 0, ptr, json.length)));
};
class End {
  constructor(ptr, wasm2) {
    __privateAdd(this, _guard);
    __privateAdd(this, _ptr2, 0);
    __privateAdd(this, _wasm, null);
    __privateSet(this, _ptr2, ptr);
    __privateSet(this, _wasm, wasm2);
  }
  [__c__]() {
    __privateSet(this, _ptr2, __privateSet(this, _wasm, null));
  }
  append(content, options = {}) {
    __privateMethod(this, _guard, guard_fn).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm).end_append(__privateGet(this, _ptr2), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
}
_ptr2 = new WeakMap();
_wasm = new WeakMap();
_guard = new WeakSet();
guard_fn = function() {
  if (!__privateGet(this, _ptr2))
    throw new Error("html: using html content past its handler return is forbidden");
};
class Doctype {
  constructor(ptr, wasm2) {
    __privateAdd(this, _guard2);
    __privateAdd(this, _ptr3, 0);
    __privateAdd(this, _wasm2, null);
    __privateSet(this, _ptr3, ptr);
    __privateSet(this, _wasm2, wasm2);
  }
  [__c__]() {
    __privateSet(this, _ptr3, __privateSet(this, _wasm2, null));
  }
  get name() {
    __privateMethod(this, _guard2, guard_fn2).call(this);
    const ptr = __privateGet(this, _wasm2).doctype_name(__privateGet(this, _ptr3));
    if (!ptr)
      return null;
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
  get publicId() {
    __privateMethod(this, _guard2, guard_fn2).call(this);
    const ptr = __privateGet(this, _wasm2).doctype_public_id(__privateGet(this, _ptr3));
    if (!ptr)
      return null;
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
  get systemId() {
    __privateMethod(this, _guard2, guard_fn2).call(this);
    const ptr = __privateGet(this, _wasm2).doctype_system_id(__privateGet(this, _ptr3));
    if (!ptr)
      return null;
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
}
_ptr3 = new WeakMap();
_wasm2 = new WeakMap();
_guard2 = new WeakSet();
guard_fn2 = function() {
  if (!__privateGet(this, _ptr3))
    throw new Error("html: using html content past its handler return is forbidden");
};
class Comment {
  constructor(ptr, wasm2) {
    __privateAdd(this, _guard3);
    __privateAdd(this, _ptr4, 0);
    __privateAdd(this, _wasm3, null);
    __privateSet(this, _ptr4, ptr);
    __privateSet(this, _wasm3, wasm2);
  }
  [__c__]() {
    __privateSet(this, _ptr4, __privateSet(this, _wasm3, null));
  }
  remove() {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    __privateGet(this, _wasm3).comment_remove(__privateGet(this, _ptr4));
    return this;
  }
  get removed() {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    return !!__privateGet(this, _wasm3).comment_removed(__privateGet(this, _ptr4));
  }
  get text() {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    const ptr = __privateGet(this, _wasm3).comment_text_get(__privateGet(this, _ptr4));
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
  set text(content) {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    const c = __privateGet(this, _wasm3).comment_text_set(__privateGet(this, _ptr4), ptr, buffer.length);
    if (c === 2)
      throw new Error("html: comment text shouldn't contain comment closing sequence (`-->`)");
    if (c === 1)
      throw new Error("html: comment text contains a character that can't be represented in utf8");
  }
  after(content, options = {}) {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm3).comment_after(__privateGet(this, _ptr4), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  before(content, options = {}) {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm3).comment_before(__privateGet(this, _ptr4), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  replace(content, options = {}) {
    __privateMethod(this, _guard3, guard_fn3).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm3).comment_replace(__privateGet(this, _ptr4), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
}
_ptr4 = new WeakMap();
_wasm3 = new WeakMap();
_guard3 = new WeakSet();
guard_fn3 = function() {
  if (!__privateGet(this, _ptr4))
    throw new Error("html: using html content past its handler return is forbidden");
};
class Text {
  constructor(ptr, wasm2) {
    __privateAdd(this, _guard4);
    __privateAdd(this, _ptr5, 0);
    __privateAdd(this, _wasm4, null);
    __privateSet(this, _ptr5, ptr);
    __privateSet(this, _wasm4, wasm2);
  }
  [__c__]() {
    __privateSet(this, _ptr5, __privateSet(this, _wasm4, null));
  }
  remove() {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    __privateGet(this, _wasm4).text_remove(__privateGet(this, _ptr5));
    return this;
  }
  get removed() {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    return !!__privateGet(this, _wasm4).text_removed(__privateGet(this, _ptr5));
  }
  get lastInTextNode() {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    return !!__privateGet(this, _wasm4).text_last_in_text_node(__privateGet(this, _ptr5));
  }
  get text() {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    const ptr = __privateGet(this, _wasm4).text_text_get(__privateGet(this, _ptr5));
    if (ptr === 0)
      return "";
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
  after(content, options = {}) {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm4).text_after(__privateGet(this, _ptr5), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  before(content, options = {}) {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm4).text_before(__privateGet(this, _ptr5), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  replace(content, options = {}) {
    __privateMethod(this, _guard4, guard_fn4).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm4).text_replace(__privateGet(this, _ptr5), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
}
_ptr5 = new WeakMap();
_wasm4 = new WeakMap();
_guard4 = new WeakSet();
guard_fn4 = function() {
  if (!__privateGet(this, _ptr5))
    throw new Error("html: using html content past its handler return is forbidden");
};
class Element {
  constructor(ptr, wasm2) {
    __privateAdd(this, _guard5);
    __privateAdd(this, _ptr6, 0);
    __privateAdd(this, _wasm5, null);
    __privateSet(this, _ptr6, ptr);
    __privateSet(this, _wasm5, wasm2);
  }
  [__c__]() {
    __privateSet(this, _ptr6, __privateSet(this, _wasm5, null));
  }
  remove() {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    __privateGet(this, _wasm5).element_remove(__privateGet(this, _ptr6));
    return this;
  }
  get removed() {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    return !!__privateGet(this, _wasm5).element_removed(__privateGet(this, _ptr6));
  }
  removeAndKeepContent() {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    __privateGet(this, _wasm5).element_remove_and_keep_content(__privateGet(this, _ptr6));
    return this;
  }
  get tagName() {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const ptr = __privateGet(this, _wasm5).element_tag_name(__privateGet(this, _ptr6));
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
  get namespaceURI() {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const ptr = __privateGet(this, _wasm5).element_namespace_uri(__privateGet(this, _ptr6));
    const str = decode_utf8(mem.u8(ptr, mem.length()));
    return mem.free(ptr, mem.length()), str;
  }
  get attributes() {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const ptr = __privateGet(this, _wasm5).element_attributes(__privateGet(this, _ptr6));
    const attributes = JSON.parse(decode_utf8(mem.u8(ptr, mem.length())));
    return mem.free(ptr, mem.length()), attributes.values();
  }
  removeAttribute(name) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(name);
    const bptr = mem.alloc(buffer.length);
    mem.u8(bptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_remove_attribute(__privateGet(this, _ptr6), bptr, buffer.length);
    return this;
  }
  hasAttribute(name) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(name);
    const bptr = mem.alloc(buffer.length);
    mem.u8(bptr, buffer.length).set(buffer);
    return !!__privateGet(this, _wasm5).element_has_attribute(__privateGet(this, _ptr6), bptr, buffer.length);
  }
  getAttribute(name) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(name);
    const bptr = mem.alloc(buffer.length);
    mem.u8(bptr, buffer.length).set(buffer);
    const ptr = __privateGet(this, _wasm5).element_get_attribute(__privateGet(this, _ptr6), bptr, buffer.length);
    if (!ptr)
      return null;
    const len = mem.length();
    const str = decode_utf8(mem.u8(ptr, len));
    return mem.free(ptr, len), str;
  }
  after(content, options = {}) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_after(__privateGet(this, _ptr6), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  append(content, options = {}) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_append(__privateGet(this, _ptr6), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  before(content, options = {}) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_before(__privateGet(this, _ptr6), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  prepend(content, options = {}) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_prepend(__privateGet(this, _ptr6), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  replace(content, options = {}) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_replace(__privateGet(this, _ptr6), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  setInnerContent(content, options = {}) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    __privateGet(this, _wasm5).element_set_inner_content(__privateGet(this, _ptr6), ptr, buffer.length, options.html ? 1 : 0);
    return this;
  }
  set tagName(content) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const buffer = encode_utf8(content);
    const ptr = mem.alloc(buffer.length);
    mem.u8(ptr, buffer.length).set(buffer);
    const c = __privateGet(this, _wasm5).element_set_tag_name(__privateGet(this, _ptr6), ptr, buffer.length);
    if (c === 1)
      throw new Error("html: tag name can't be empty");
    if (c === 3)
      throw new Error("html: forbidden character is in the tag name");
    if (c === 2)
      throw new Error("html: tag name contains a character that can't be represented in utf8");
    if (c === 4)
      throw new Error("html: first character of the tag name should be an ASCII alphabetical character");
  }
  setAttribute(name, value) {
    __privateMethod(this, _guard5, guard_fn5).call(this);
    const v = encode_utf8(value);
    const key = encode_utf8(name);
    const vptr = mem.alloc(v.length);
    const kptr = mem.alloc(key.length);
    mem.u8(vptr, v.length).set(v);
    mem.u8(kptr, key.length).set(key);
    const c = __privateGet(this, _wasm5).element_set_attribute(__privateGet(this, _ptr6), kptr, key.length, vptr, v.length);
    if (c === 1)
      throw new Error("html: attribute name can't be empty");
    if (c === 3)
      throw new Error("html: forbidden character is in the attribute name");
    if (c === 2)
      throw new Error("html: attribute name contains a character that can't be represented in utf8");
    return this;
  }
}
_ptr6 = new WeakMap();
_wasm5 = new WeakMap();
_guard5 = new WeakSet();
guard_fn5 = function() {
  if (!__privateGet(this, _ptr6))
    throw new Error("html: using html content past its handler return is forbidden");
};
