[編集モード] plugin_weykpng PNGファイル操作Plugin

PNGのファイルを内容を操作するためのplugin。Javascript形式。

class PNGchunk {
  static registeredChunk = new Map();

constructor(chunk) {
    this.chunkType=chunk;
    this.chunkTypeRaw=new Uint8Array(4);
    this.chunkTypeRaw[0]=chunk.charCodeAt(0);
    this.chunkTypeRaw[1]=chunk.charCodeAt(1);
    this.chunkTypeRaw[2]=chunk.charCodeAt(2);
    this.chunkTypeRaw[3]=chunk.charCodeAt(3);
    this.chunkRaw = new ArrayBuffer(0);
    this.chunkCrc = 0;
  }

static registerChunk(chunk, func) {
    this.registeredChunk.set(chunk, func);
  }

static createFromRaw(f,o) {
    const view = new DataView(f);
    const t = String.fromCharCode(view.getUint8(o+4),view.getUint8(o+5),view.getUint8(o+6),view.getUint8(o+7));
    const c = this.registeredChunk.get(t);
    let chunk = null;
    if (c !== undefined) {
      chunk = new c();
    } else {
      chunk = new PNGchunk(t);
    }
    chunk.setFromRaw(f, o);
    chunk.parseRaw();
    return chunk;
  }

setFromRaw(f,o) {
    const view = new DataView(f);
    this.chunkLength = view.getUint32(o,false);
    o += 4;
    this.chunkTypeRaw = new Uint8Array(f.slice(o,o+4));
    this.chunkType = String.fromCharCode(this.chunkTypeRaw[0],this.chunkTypeRaw[1],this.chunkTypeRaw[2],this.chunkTypeRaw[3]);
    o += 4;
    this.chunkRaw = f.slice(o,o+this.chunkLength);
    o += this.chunkLength;
    this.chunkCrc = view.getUint32(o,false);
  }

parseRaw() {
  }

generateRaw() {
    if (this.chunkRaw == null) {
      this.chunkRaw = new ArrayBuffer(0);
      this.chunkLength=0;
    }
  }

updateCrc() {
    const crc = new CRC32();
    crc.update(this.chunkTypeRaw);
    crc.update(this.chunkRaw);
    this.chunkCrc = crc.finish();
  }

getBytes() {
    this.generateRaw();
    this.updateCrc();
    const buf = new ArrayBuffer(this.chunkLength+12);
    this.setBytes(buf, o);
    return buf;
  }

setBytes(buf, o) {
    const view8 = new Uint8Array(buf, o, this.chunkLength+12);
    const setFromArrayBuffer = (ui8, buf, o) => {
      const views = new Uint8Array(buf);
      ui8.set(views, o);
    }
    setFromArrayBuffer(view8, this.chunkTypeRaw, 4);
    setFromArrayBuffer(view8, this.chunkRaw, 8);
    const view = new DataView(buf, o, this.chunkLength+12);
    view.setUint32(0, this.chunkLength);
    view.setUint32(8+this.chunkLength, this.chunkCrc);
  }
}

class gAMA extends PNGchunk {
  constructor() {
    super('gAMA');
    this.gamma = 1.0;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.gamma = view.getUint32(0,false) / 100000;
  }
  generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 4) {
      this.chunkRaw = new ArrayBuffer(4);
    }
    this.chunkLength = 4;
    const view = new DataView(this.chunkRaw,0);
    view.setUint32(0,this.gamma * 100000,false);
  }
}
PNGchunk.registerChunk('gAMA',gAMA);

class sRGB extends PNGchunk {
  constructor() {
    super('sRGB');
    this.renderingIntent = 0;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.renderingIntent = view.getUint8(0);
  }
  generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 1) {
      this.chunkRaw = new ArrayBuffer(1);
    }
    this.chunkLength = 1;
    const view = new DataView(this.chunkRaw,0);
    view.setUint8(0,this.renderingIntent);
  }
}
PNGchunk.registerChunk('sRGB',sRGB);

class IEND extends PNGchunk {
  constructor() {
    super('IEND');
  }

generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 0) {
      this.chunkRaw = new ArrayBuffer(0);
    }
    this.chunkLength=0;
  }
}
PNGchunk.registerChunk('IEND',IEND);

class IDAT extends PNGchunk {
  constructor() {
    super('IDAT');
  }

generateRaw() {
    if (this.chunkRaw == null) {
      this.chunkRaw = new ArrayBuffer(0);
      this.chunkLength=0;
    }
  }
}
PNGchunk.registerChunk('IDAT',IDAT);

class IHDR extends PNGchunk {
  constructor() {
    super('IHDR');
    this.width = 0;
    this.height = 0;
    this.bitDepth = 32;
    this.colorType = 0;
    this.compression = 0;
    this.filter = 0;
    this.interlace = 0;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.width = view.getUint32(0,false);
    this.height = view.getUint32(4,false);
    this.bitDepth = view.getUint8(8);
    this.colorType = view.getUint8(9);
    this.compression = view.getUint8(10);
    this.filter = view.getUint8(11);
    this.interlace = view.getUint8(12);
  }
  generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 13) {
      this.chunkRaw = new ArrayBuffer(13);
    }
    this.chunkLength = 13;
    const view = new DataView(this.chunkRaw,0);
    view.setUint32(0,this.width,false);
    view.setUint32(4,this.height,false);
    view.setUint8(8,this.bitDepth);
    view.setUint8(9,this.colorType);
    view.setUint8(10,this.compression);
    view.setUint8(11,this.filter);
    view.setUint8(12,this.interlace);
  }
}
PNGchunk.registerChunk('IHDR',IHDR);

class PLTE extends PNGchunk {
  constructor() {
    super('PLTE');
    this.palette = [];
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    const l = this.chunkLength;
    let i = 0;
    this.palette = [];
    while (i < l) {
      const p = [view.getUint8(i+0),view.getUint8(i+1),view.getUint8(i+2)];
      this.palette.push(p);
      i+=3;
    }
  }
  generateRaw() {
    const l = this.palette.length * 3;
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== l) {
      this.chunkRaw = new ArrayBuffer(l);
    }
    this.chunkLength = l;
    const view = new DataView(this.chunkRaw,0);
    let i = 0;
    while (i < l / 3) {
      const p = this.palette[i];
      view.setUint8(i*3+0,p[0]);
      view.setUint8(i*3+1,p[1]);
      view.setUint8(i*3+2,p[2]);
      i++;
    }
  }
}
PNGchunk.registerChunk('PLTE',PLTE);

class tRNS extends PNGchunk {
  constructor() {
    super('tRNS');
    this.colorType = -1;
    this.alphas = 0;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    const l = this.chunkLength;
  }
  reparseRaw(colorType) {
    this.colorType = colorType;
    const view = new DataView(this.chunkRaw,0);
    if (colorType === 0) {
      this.alphas = view.getUint16(0, false);
    } else
    if (colorType === 2) {
      this.alphas = [view.getUint16(0,false),view.getUint16(2,false),view.getUint16(4,false)];
    } else
    if (colorType === 3) {
      this.alphas = [];
      const l = this.chunkLength;
      for (let i=0;i<l;i++) {
        this.alphas.push(view.getUint8(i));
      }
    } else {
      throw new Error('color type error in tRNS chunk. require set.');
    }
  }
  generateRaw() {
    if (this.colorType === 0) {
      if (this.chunkRaw == null || this.chunkRaw.byteLength !== 2) {
        this.chunkRaw = new ArrayBuffer(2);
      }
      this.chunkLength = 2;
      const view = new DataView(this.chunkRaw,0);
      let alpha = this.alphas;
      if (Array.isArray(alpha)) {
        alpha = alpha[0];
      }
      view.setUint16(0,alpha,false);
    } else
    if (this.colorType === 2) {
      if (this.chunkRaw == null || this.chunkRaw.byteLength !== 6) {
        this.chunkRaw = new ArrayBuffer(6);
      }
      this.chunkLength = 6;
      const view = new DataView(this.chunkRaw,0);
      view.setUint16(0,this,alphas[0],false);
      view.setUint16(2,this,alphas[1],false);
      view.setUint16(4,this,alphas[2],false);
    } else
    if (this.colorType === 3) {
      if (Array.isArray(this.alphas)) {
        const l = this.alphas.length;
        if (this.chunkRaw == null || this.chunkRaw.byteLength !== l) {
          this.chunkRaw = new ArrayBuffer(l);
        }
        this.chunkLength = l;
        const view = new DataView(this.chunkRaw,0);
        let i = 0;
        for (let i=0;i<l;i++) {
          view.setUint8(i, this.alphas[i]);
        }
      } else {
        if (this.chunkRaw == null || this.chunkRaw.byteLength !== 1) {
          this.chunkRaw = new ArrayBuffer(1);
        }
        this.chunkLength = 1;
        const view = new DataView(this.chunkRaw,0);
        view.setUint8(0, this.alphas);
      }
    } else {
      throw new Error('color type error in tRNS chunk. require set.');
    }
  }
}
PNGchunk.registerChunk('tRNS',tRNS);

class pHYs extends PNGchunk {
  constructor() {
    super('pHYs');
    this.pixelDimensionsX = 1;
    this.pixelDimensionsY = 1;
    this.unit = 0;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.pixelDimensionsX = view.getUint32(0,false);
    this.pixelDimensionsY = view.getUint32(4,false);
    this.unit = view.getUint8(8);
  }
  generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 9) {
      this.chunkRaw = new ArrayBuffer(9);
    }
    this.chunkLength = 9;
    const view = new DataView(this.chunkRaw,0);
    view.setUint32(0,this.pixelDimensionsX,false);
    view.setUint32(4,this.pixelDimensionsY,false);
    view.setUint8(8,this.unit);
  }
}
PNGchunk.registerChunk('pHYs',pHYs);

class tEXt extends PNGchunk {
  constructor() {
    super('tEXt');
    this.key = '';
    this.text = '';
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    let l = this.chunkLength;
    let i = 0;
    let v = '';
    while (l > 0) {
      const c = view.getUint8(i);
      if (c === 0) {
        this.key = v;
        v='';
      } else {
        v += String.fromCharCode(c);
      }
      i++;
      l--;
    }
    this.text = v;
  }
  generateRaw() {
    const l = this.key.length + this.text.length + 1;
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== l) {
      this.chunkRaw = new ArrayBuffer(l);
    }
    this.chunkLength = l;
    const view = new DataView(this.chunkRaw,0);
    let o = 0;
    let i;
    for (i=0;i<this.key.length;i++) {
      view.setUint8(o,this.key.charCodeAt(i));
      o++;
    }
    view.setUint8(o,0);
    o++;
    for (i=0;i<this.text.length;i++) {
      view.setUint8(o,this.text.charCodeAt(i));
      o++;
    }
  }
}
PNGchunk.registerChunk('tEXt',tEXt);

// for animated PNG
class acTL extends PNGchunk {
  constructor() {
    super('acTL');
    this.num_frames = 0;
    this.num_plays = 1;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.num_frames = view.getUint32(0,false);
    this.num_plays = view.getUint32(4,false);
  }
  generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 8) {
      this.chunkRaw = new ArrayBuffer(8);
    }
    this.chunkLength = 8;
    const view = new DataView(this.chunkRaw,0);
    view.setUint32(0,this.num_frames,false);
    view.setUint32(4,this.num_plays,false);
  }
}
PNGchunk.registerChunk('acTL',acTL);

class fcTL extends PNGchunk {
  constructor() {
    super('fcTL');
    this.sequence_number = 0;
    this.width = 1;
    this.height = 1;
    this.x_offset = 0;
    this.y_offset = 0;
    this.delay_num = 500;
    this.delay_den = 1;
    this.dispose_op = 0;
    this.blend_op = 0;
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.sequence_number = view.getUint32(0,false);
    this.width = view.getUint32(4,false);
    this.height = view.getUint32(8,false);
    this.x_offset = view.getUint32(12,false);
    this.y_offset = view.getUint32(16,false);
    this.delay_num = view.getUint16(20,false);
    this.delay_den = view.getUint16(22,false);
    this.dispose_op = view.getUint8(24);
    this.blend_op = view.getUint8(25);
  }
  generateRaw() {
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== 26) {
      this.chunkRaw = new ArrayBuffer(26);
    }
    this.chunkLength = 26;
    const view = new DataView(this.chunkRaw,0);
    view.setUint32(0,this.sequence_number,false);
    view.setUint32(4,this.width,false);
    view.setUint32(8,this.height,false);
    view.setUint32(12,this.x_offset,false);
    view.setUint32(16,this.y_offset,false);
    view.setUint16(20,this.delay_num,false);
    view.setUint16(22,this.delay_den,false);
    view.setUint8(24,this.dispose_op);
    view.setUint8(25,this.blend_op);
  }
}
PNGchunk.registerChunk('fcTL',fcTL);

class fdAT extends PNGchunk {
  constructor() {
    super('fdAT');
    this.sequence_number = 0;
    this.imageRaw = new ArrayBuffer(0);
  }
  parseRaw() {
    const view = new DataView(this.chunkRaw,0);
    this.sequence_number = view.getUint32(0,false);
    this.imageRaw = this.chunkRaw.slice(4);
  }
  generateRaw() {
    const l = 4+this.imageRaw.byteLength;
    if (this.chunkRaw == null || this.chunkRaw.byteLength !== l) {
      this.chunkRaw = new ArrayBuffer(l);
    }
    this.chunkLength = l;
    const setFromArrayBuffer = (ui8, buf, o) => {
      const views = new Uint8Array(buf);
      ui8.set(views, o);
    }
    const view = new DataView(this.chunkRaw,0);
    view.setUint32(0,this.sequence_number,false);
    const view8 = new Uint8Array(this.chunkRaw,0);
    setFromArrayBuffer(view8, this.imageRaw, 4);
  }
}
PNGchunk.registerChunk('fdAT',fdAT);

class PNGsignature {
  static signature = new Uint8Array([137,80,78,71,13,10,26,10]);

constructor() {
    this.chunks = [];
  }

static check(f) {
    const view = new Uint8Array(f.slice(0,8));
    if (view.length !== 8) return false;
    if (view.join(',') !== this.signature.join(',')) return false;
    return true;
  }

getRaw() {
    return this.constructor.signature;
  }

static createFromRaw(f) {
    let o = 0;
    if (PNGsignature.check(f)) {
      const p = new PNGsignature();
      o += 8;
      let colorType = -1;
      while (o < f.byteLength) {
        var pc = PNGchunk.createFromRaw(f,o);
        o += pc.chunkLength + 12;
        p.chunks.push(pc);
        if (pc.chunkType==='IHDR') {
          colorType = pc.colorType;
        } else
        if (pc.chunkType==='tRNS') {
          pc.reparseRaw(colorType);
        }
      }
      return p;
    }
    return null;
  }

getBytes() {
    let totallength = 8; // signature length
    this.chunks.forEach(c => {
      c.generateRaw();
      c.updateCrc();
      totallength += 12 + c.chunkLength;
    });
    const buf = new ArrayBuffer(totallength);
    let o = 0;
    const view8 = new Uint8Array(buf);
    view8.set(this.getRaw(), o);
    o+=8;
    this.chunks.forEach(c => {
      c.setBytes(buf, o);
      o += 12 + c.chunkLength;
    });
    return buf;
  }
}

class BitReader {
  constructor(buf) {
    this.dataRaw = buf;
    this.view = new DataView(this.dataRaw);
    this.currentIndex = 0;
    this.remainBit = 0;
    this.remainData = 0;
  }

seekOffset(n) {
    this.currentIndex = n;
    this.remainBit = 0;
  }

getOffset() {
    return this.currentIndex;
  }

alignByte() {
    this.remainBit = 0;
  }

getUint8() {
    this.remainBit = 0;
    const data = this.view.getUint8(this.currentIndex);
    this.currentIndex+=1;
    return data;
  }

getUint16(f) {
    this.remainBit = 0;
    const data = this.view.getUint16(this.currentIndex,f);
    this.currentIndex+=2;
    return data;
  }

getUint32(f) {
    this.remainBit = 0;
    const data = this.view.getUint32(this.currentIndex,f);
    this.currentIndex+=4;
    return data;
  }

getBits(n,f) {
   return f ? this.getBitsN(n) : this.getBitsR(n);
  }

getBitsN(n) {
    let work = 0;
    while (n > 0) {
      if (this.remainBit === 0) {
        if (this.currentIndex >= this.dataRaw.byteLength) {
          return -1;
        }
        this.remainBit = 8;
        this.remainData = this.view.getUint8(this.currentIndex);
        this.currentIndex++;
      }
      work = (work << 1) | (this.remainData & 1);
      this.remainData >>>= 1;
      this.remainBit--;
      n--;
    }
    return work;
  }

getBitsR(n) {
    let work = 0;
    let base = 0;
    while (n > 0) {
      if (this.remainBit === 0) {
        if (this.currentIndex >= this.dataRaw.byteLength) {
          return -1;
        }
        this.remainBit = 8;
        this.remainData = this.view.getUint8(this.currentIndex);
        this.currentIndex++;
      }
      if (n <= this.remainBit) {
        const m = (1 << n)-1;
        work |= (this.remainData & m) << base;
        this.remainData >>>= n;
        this.remainBit-=n;
        n=0;
      } else {
        const m = (1 << this.remainBit)-1
        work |= (this.remainData & m) << base;
        base+=this.remainBit;
        n-=this.remainBit;
        this.remainBit=0;
      }
    }
    return work;
  }
}

class CRC32 {
  static crc_table=[];
  static crc_table_computed = false;

static make_crc_table() {
    for (let i = 0; i < 256; i++) {
      let c = i;
      for (let j = 0; j < 8; j++) {
        if (c & 1 !== 0) {
          c = 0xedb88320 ^ (c >>> 1);
        } else {
          c = c >>> 1;
        }
      }
      this.crc_table[i] = c >>> 0;
    }
    this.crc_table_computed = true;
  }

constructor() {
    this.reset();
  }

reset() {
    this.crc = 0xffffffff;
  }

update(buf) {
    let c = this.crc;
    if (!this.constructor.crc_table_computed) {
      this.constructor.make_crc_table();
    }

let u8array = buf;
    if (u8array instanceof ArrayBuffer) {
      u8array = new Uint8Array(buf);
    }
    const l = u8array.length;
    for (let i = 0; i < l; i++) {
      const n = u8array[i];
      c = ( this.constructor.crc_table[(c ^ n) & 0xff] ^ (c >>> 8) ) >>> 0;
    }
    this.crc = c;
    return c;
  }

finish() {
    return (this.crc ^ 0xffffffff) >>> 0;
  }
}

class ADLER32 {
  constructor() {
    this.reset();
  }

reset() {
    this.a = 1;
    this.b = 0;
  }

update(buf) {
    let a = this.a;
    let b = this.b;

finish() {
    return ((b << 16) | a) >>> 0;
  }
}

function makeFixODict() {
  const dict = {};
  dict["min"]=5;
  dict["max"]=5;
  dict[5]={};
  for (i=0;i<=31;++i) {
    dict[5][i]=i;
  }
  return dict;
}

class PluginPngSystem {
  constructor (sys) {
    this.sys = sys
  }
  clearAll () {
    // nop
  }
  static registNakoSys (sys) {
    if (sys == null) { return null }
    if (sys.tags) {
      sys.tags.weyk_png = new PluginPngSystem(sys)
    } else {
      sys._weyk_png = new PluginPngSystem(sys)
    }
  }
  static getWeykpngIfExist (sys) {
    if (sys == null) { return null }
    if (sys.tags && sys.tags.weyk_png) {
      return sys.tags.weyk_png
    } else
    if (sys._weyk_png) {
      return sys._weyk_png
    }
    return null
  }
  static getWeykpng (sys) {
    const weykpng = PluginPngSystem.getWeykpngIfExist(sys)
    if (!weykpng) {
      throw new Error('プラグインが初期化されていません')
    }
    return weykpng
  }
  static alreadyRegist (sys) {
    const weykpng = PluginPngSystem.getWeykpngIfExist(sys)
    if (!weykpng) { return false }
    if (weykpng.sys !== sys) { return false }
    return true
  }
}

const PluginPNG = {
  'meta': {
    type: 'const',
    value: {
      pluginName: 'plugin_weykpng', // プラグインの名前
      description: 'PNGをCHUNK単位で操作するためのプラグイン', // 説明
      pluginVersion: '1.1.0', // プラグインのバージョン
      nakoRuntime: ['wnako'], // 対象ランタイム
      nakoVersion: '3.6.2' // 要求なでしこバージョン
    }
  },
  '初期化': {
    type: 'func',
    josi: [],
    pure: true,
    fn: function (sys) {
      if (PluginPngSystem.alreadyRegist(sys)) { return }
      PluginPngSystem.registNakoSys(sys)
    }
  },

'!クリア': {
    type: 'func',
    josi: [],
    pure: true,
    fn: function (sys) {
      const weykpng = PluginPngSystem.getWeykpngIfExist(sys)
      if (weykpng) {
        weykpng.clearAll()
      }
    }
  },

// @PNGファイル
  'PNG作成': { // @空のPNGファイルオブジェクトを作成して返す // @PNGさくせい
    type: 'func',
    josi: [],
    pure: true,
    fn: function (sys) {
      return new PNGsignature()
    }
  },
  'PNG読込': { // @バッファからPNGファイルオブジェクトを作成して返す // @PNGよみこみ
    type: 'func',
    josi: [['から','を']],
    pure: true,
    fn: function (f, sys) {
      return PNGsignature.createFromRaw(f)
    }
  },
  'PNG取出': { // @PNGファイルオブジェクトからバッファを取り出して返す // @PNGとりだし
    type: 'func',
    josi: [['から','を']],
    pure: true,
    fn: function (png, sys) {
      return png.getBytes()
    }
  },
  'PNGチャンク追加': { // @PNGファイルオブジェクトにチャンクを追加する // @PNGちゃんくついか
    type: 'func',
    josi: [['に'],['を']],
    pure: true,
    fn: function (png, chunk, sys) {
      png.chunks.push(chunk)
    }
  },
  'PNGチャンク配列取得': { // @PNGファイルオブジェクトからチャンクの配列を取得して返す // @PNGちゃんくはいれつしゅとく
    type: 'func',
    josi: [['から','の']],
    pure: true,
    fn: function (png, sys) {
      return png.chunks
    }
  },
  'PNGチャンク配列設定': { // @PNGファイルオブジェクトのチャンクの配列を置き換える // @PNGちゃんくはいれつせってい
    type: 'func',
    josi: [['の'],['を']],
    pure: true,
    fn: function (png, chunks, sys) {
      png.chunks = chunks
    }
  },
  'PNGチャンク配列クリア': { // @PNGファイルオブジェクトのチャンクの配列をクリアする // @PNGちゃんくはいれつくりあ
    type: 'func',
    josi: [['から','の']],
    pure: true,
    fn: function (png, sys) {
      png.chunks=[]
    }
  },
  'PNGチャンク作成': { // @PNGのチャンクの配列を作成して返す // @PNGちゃんくさくせい
    type: 'func',
    josi: [['の']],
    pure: true,
    fn: function (chunktype, sys) {
      const c = PNGchunk.registeredChunk.get(chunktype)
      let chunk = null;
      if (c !== undefined) {
        chunk = new c();
      } else {
        chunk = new PNGchunk(chunktype);
      }
      return chunk
    }
  },
  'PNGInflate': { // @PNGに含まれるDeflateの伸長を行い返す // @PNGInflate
    type: 'func',
    josi: [['を']],
    pure: true,
    fn: function (buf, sys) {
      return inflate(buf);
    }
  }
}

if (typeof (navigator) === 'object' && typeof (navigator.nako3)) {
  navigator.nako3.addPluginObject('PluginPNG', PluginPNG)
}

デバッグ × キャンバス: 幅 × 高

🍯 なでしこ3貯蔵庫

[編集モード] plugin_weykpng PNGファイル操作Plugin

素材のアップロード